Why Lambda Expressions

Now Lets Iterate through the simple ArrayList

Without Lambda Expressions

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

for (int number : numbers) 
{
    System.out.println(number);
}

We iterate the collection externally, explicitly pulling out and processing the items one by one. Now through Lambda Expressions, we are using an internal iteration the JIT compiler could optimize it processing the items in parallel or in a different order. These optimizations are impossible if we iterate the collection externally as we are used to doing in Java and more in general with the imperative programming.

With Lambda Expressions

numbers.forEach((Integer value) -> System.out.println(value));

(or)

numbers.forEach(value -> System.out.println(value));

Apart from the above reason Lambdas allows us to

  • Enable to treat functionality as a method argument, or code as data.
  • A function that can be created without belonging to any class.
  • A lambda expression can be passed around as if it was an object and executed on demand.
  • It reduces the line of code.
  • It Supports Sequential and Parallel execution by passing behavior in methods with collection stream API
  • Using Stream API and lambda expression we can achieve higher efficiency (parallel execution) in the case of bulk operations on collections

Java 8 Lambda uses JVM Opcode – invokedynamic

The Following code will result in Anonymous class being created when you compile the code.
So if you have 10 anonymous classes then it would be 10 more classes like(ClassName$1.class,ClassName$2.class….ClassName$10.class) in the final jar.

AccountService accountServiceAnonymous = new AccountService(){
    public void createAccount(){
        Account account = new Account();
        save(account);
    }
};

But Java 8 lambda uses invokedynamic to call lambdas thus if you have 10 lambdas it will not result in any anonymous classes thus reducing the final jar size.

AccountService accountServiceLambda = () -> {
    Account account = new Account();
    save(account);
}

Below is a code example of CustomClass Loader which Servers use internally for HotCode Swap without restarting the server.When you change the Quote in ServerImpl.java file the file should be reloaded by selecting the RELOAD option while running Client.java

IServer.java

public interface IServer {
	public String getQuote();
}

ServerImpl.java

public class ServerImpl implements IServer{
	@Override
    public String getQuote() {
        return "Its Working Man";
    }
}

Client.java

import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Client {
    static ClassLoader cl;
    static IServer server;

    public static void reloadServer() throws Exception {
        URL[] urls = new URL[]{new URL("file:///D:/java/HotDeplyment/appclasses")};
        System.out.println("Reloaded.....");
        cl = new URLClassLoader(urls);
        server  = (IServer) cl.loadClass("com.mugil.org.ServerImpl").newInstance();
    }

    public static void main(String [] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        reloadServer();
        while (true) {
            System.out.print("Enter QUOTE, RELOAD, or QUIT: ");
            String cmdRead = br.readLine();
            String cmd = cmdRead.toUpperCase();
            if (cmd.equals("QUIT")) {
                return;
            } else if (cmd.equals("QUOTE")) {
                System.out.println( server.getQuote());
            } else if (cmd.equals("RELOAD")) {
            	reloadServer();
            }
        }
    }
}

The Above code is not working as windows is not clearing cached .class files or JAR files. So the alternative is to try with the below Custom Class Loader(MyURLClassLoader) which in turn extends URLClassLoader again.

MyURLClassLoader.java

import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Collection;
import java.util.jar.JarFile;

public class MyURLClassLoader extends URLClassLoader {

	public MyURLClassLoader(URL[] urls, ClassLoader parent) {
	    super(urls, parent);
	}

    /**
     * Closes all open jar files
     */
    public void close() {
        try {
            Class clazz = java.net.URLClassLoader.class;
            Field ucp = clazz.getDeclaredField("ucp");
            ucp.setAccessible(true);
            Object sunMiscURLClassPath = ucp.get(this);
            Field loaders = sunMiscURLClassPath.getClass().getDeclaredField("loaders");
            loaders.setAccessible(true);
            Object collection = loaders.get(sunMiscURLClassPath);
            for (Object sunMiscURLClassPathJarLoader : ((Collection) collection).toArray()) {
                try {
                    Field loader = sunMiscURLClassPathJarLoader.getClass().getDeclaredField("jar");
                    loader.setAccessible(true);
                    Object jarFile = loader.get(sunMiscURLClassPathJarLoader);
                    ((JarFile) jarFile).close();
                } catch (Throwable t) {
                    // if we got this far, this is probably not a JAR loader so skip it
                }
            }
        } catch (Throwable t) {
            // probably not a SUN VM
        }
        return;
    }
}

In the below code the CustomClass Loader is called to load the classes which inturn calls the Super Class loader which is again Loaders from URL Class Loader.Once it is done we have defined a custom close method which closes the JAR files or .class files which is loaded by class loader.

TestClassLoader.java

package com.mugil.org;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;

public class TestClassLoader {
	static ClassLoader cl;
    static IServer server;
	
	public static void main(String[] args) throws Exception {
		
		while(true) {
			try {
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			TestClassLoader obj = new TestClassLoader();
			obj.loadAndInstantiate();			
			System.out.println(server.getQuote());			
			}
			catch (Exception e){
				
			}
			finally {
				try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
			}
		}    
	}
	
	void loadAndInstantiate() throws Exception {
	    MyURLClassLoader cl = null;
	    try {	    	
	        File file = new File("D:\\java\\HotDeplyment\\bin\\Sample.jar");
	        String classToLoad = "com.mugil.org.ServerImpl";
	        URL jarUrl = new URL("file:" + file.getAbsolutePath());
	        cl = new MyURLClassLoader(new URL[] {jarUrl}, getClass().getClassLoader());
	        Class loadedClass = cl.loadClass(classToLoad);
	        Object o = loadedClass.getConstructor().newInstance();
	        server  = (IServer) o;
	        
	    } finally {
	        if(cl != null)
	            cl.close();
	    } 
	}
}

Since the infinite while loop is called indefinitely with the thread sleep interval of every 3 seconds we replace the JAR file in the middle which takes the class from the new JAR file loaded.You need to change the ServerImpl.java file and build the JDK before you want to see the changes

Output

.
.
Its Working Man
Its Working Man
Its Working Man
Its Working Man
Its Working 
Its Working 
Its Working 
.
.

The Above code is not working either

Why Tomcat Server does not needs restart if changes are done in servlet and JSP?
Tomcat is capable of adding/modifying classpath to Web Application classloader at runtime. Tomcat will be having their custom Classloader implementation which allows them to add the classpaths at runtime.a new classloader is created for the Servlet/JSP with Application classloader as parent classloader. And the new classloader will load the modified class again.

It is always best to reload the entire application incase changes are done to servlet. If you were simply to reload one class, in isolation, you might break dependencies or miss some initialization steps. Therefore, it’s much safer to reload the entire application clicking deploy option in tomcat server.JSPs on the other hand, when properly coded, shouldn’t have anything in them by markup text. So reloading a single JSP, without reloading the entire app, should be safe. By default, tomcat is started in development mode, which means JSP-derived servlets recompiled when a change is detected.

In the web.xml you need to set the below config

<servlet>
   .
   .
    <!-- Add the following init-param -->
    <init-param>
        <param-name>development</param-name>
        <param-value>true</param-value>
    </init-param>
   .
   .
   .
</servlet>

In the Server.xml reloadable should be set to true

<Context path="/simple" docBase="webapps/simple"  debug="0" reloadable="true" ></Context>

More on how CustomClass loader works for Hot Deployment here

Class Loaders
Let’s take two simple Java Files as below

Helper.java

package com.mugil.org;
public class Helper {
	public String getMessage()
	{
		return "Helper Method";
	}
}

TestHelper.java

package com.mugil.org;
public class TestHelper {
	public static void main(String[] args) {
		Helper objHelper = new Helper();
		System.out.println(objHelper.getMessage());
	}
}

How to Compile class in Command Prompt
Normally when you compile Java class the class files would be created in bin folder with
the folder structure same as package name bin->com->mugil->org.
When you want the .class to be created in a specific folder then use the below command

D:\java\ClassLoaders>javac -d classes -sourcepath src src\com\mugil\org\Helper.java

Classes folder should be created manually or it’s going to throw
javac: directory not found: classes

Before Running the code the Classpath needs to be set which could be done either globally
by adding to the System classPath or locally at the application level

To Set globally the following should be run in Command Prompt

D:\java\ClassLoaders>set CLASSPATH=classes

After this, the Java code can be run as below

D:\java\ClassLoaders>java com.mugil.org.TestHelper
Helper Method

Setting Globally is not a good idea as other applications Classpath would be affected.If you
have set classpath globally chances are you may end up running wrong JAR file in the Classpath
The Better option is to set classpath while running the application itself

D:\java\ClassLoaders>java -cp classes com.mugil.org.TestHelper
Helper Method

Now let’s see how to take .class files in some other folder or .class files in JAR folder to

To run the .class file in other folders along with the one we are running adding the .class files separated by semicolon would be an easy way
as below

D:\java\ClassLoaders>java -cp D:\java\ClassLoaders\classes;D:\class1; com.mugil.org.TestHelper
Helper Method

The Helper.class is moved to D:\class1 folder and TestHelper.class is in D:\java\ClassLoaders\classes folder
TestHelper.class needs Helper.class to run.

Now how about JAR Files

D:\class1>jar cvf helper.jar com\mugil\org\Helper.class
added manifest
adding: com/mugil/org/Helper.class(in = 296) (out= 227)(deflated 23%)

To run the classes in the JAR Files the same command applies.D:\class1 is the location where the JAR’s are located(helper.jar).

D:\java\ClassLoaders>java -cp D:\java\ClassLoaders\classes;D:\class1; com.mugil.org.TestHelper
Helper Method

Once the JAR is created the .class files can be deleted and added to lib folder

While Creating JAR make sure you maintain the folder structure.Creating JAR file without adding com\mugil\org folder will result in classNotFound Exception

D:\java\ClassLoaders>java -cp D:\java\ClassLoaders\classes\lib\Helper.jar;D:\java\ClassLoaders\classes\; com.mugil.org.TestHelper

Class loaders are the part of the Java Runtime Environment that dynamically loads Java classes into the Java virtual machine. It is responsible for locating libraries, reading content and loading the classes contained within the libraries. When JVM is started three class loaders are used

How ClassLoaders works

  1. When JVM requests for a class, it invokes loadClass function of the ClassLoader by passing the fully classified name of the Class.
  2. loadClass function calls for findLoadedClass() method to check that the class has been already loaded or not. It’s required to avoid loading the class multiple times.
  3. If the Class is not already loaded then it will delegate the request to parent ClassLoader to load the class.
  4. If the parent ClassLoader is not finding the Class then it will invoke findClass() method to look for the classes in the file system.

1. Bootstrap class loader (Written in C)
2. Extensions class loader (Written in Java)
3. System or Application class loader (Written in Java)

Apart from CLASSPATH java looks into two other locations to load the JAR Folder
C:\Program Files\Java\jdk1.8.0_111\jre\lib in JRE installation Folder
C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext

Bootstrap class loader
It loads JDK internal classes, typically loads rt.jar and other core classes for example java.lang.* package classes

rt.jar is one of the JAR files in JRE Folder. You can see the content in rt.jar by renaming it into rt.jar.
rt.jar is loaded by the bootstrap class loader.

Extensions class loader
It loads classes from the JDK extensions directory, usually $JAVA_HOME/lib/ext directory.
You can add your JAR files like DB Connection JAR in the EXT folder and would be available to all application which runs on JVM

helper.jar added to ext folder

D:\java\ClassLoaders>java -cp D:\java\ClassLoaders\classes;D:\class1; com.mugil.org.TestHelper
Helper Method

D:\java\ClassLoaders>java -cp D:\java\ClassLoaders\classes; com.mugil.org.TestHelper
Helper Method

Note:In the second statement the D:\class1 is missing which has the JAR files which is now moved to EXT folder.No need to specify the JAR files as JAR files in EXT are loaded by default

System (or) Application class loader
System or Application class loader and it is responsible for loading application specific classes from CLASSPATH environment variable, -classpath or -cp command line option, Class-Path attribute of Manifest file inside JAR.

Delegation of Classes

  1. Delegation Classes are classes which delegates the call to its Parent Class which inturn Delegates to its Parent
  2. Each class loader has a parent. Class Loaders may delegate to its Parent. Parent may or may not load the class
  3. Loaded classes are always cached
  4. Application loader asks the Extension Class loader which inturn asks Bootstap loader
  5. If Bootstap loader couldnt find the class it will send fail message which makes the Extension Class loader to search for classes within
  6. If Extension loader couldnt find the class it will send fail message to Application Class Loader and makes to search for classes within
  7. If Application Class loader couldnt find the class NoClassDefinition Error would be Displayed

import java.net.URLClassLoader;

public class Delegation 
{
	public static void main(String[] args) 
	{
		URLClassLoader classloader = (URLClassLoader)ClassLoader.getSystemClassLoader();
		
		do {
			System.out.println(classloader);
		} while ((classloader = (URLClassLoader)classloader.getParent()) != null);
		
		System.out.println("Bootstrap ClassLoader");
	}
}

Output

sun.misc.Launcher$AppClassLoader@1497b7b1
sun.misc.Launcher$ExtClassLoader@749cd006
Bootstrap ClassLoader

To See the location of the Class Files loaded you can use the below code

.
.
do {
			System.out.println(classloader);
			
			for(URL url : classloader.getURLs())		
			 System.out.println("\t %s"+ url.getPath());
			
		} while ((classloader = (URLClassLoader)classloader.getParent()) != null);
.
.

Output

sun.misc.Launcher$AppClassLoader@1497b7b1
	 %s/D:/java/ClassLoaders/bin/
sun.misc.Launcher$ExtClassLoader@749cd006
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/access-bridge-64.jar
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/dnsns.jar
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/jaccess.jar
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/localedata.jar
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/sunec.jar
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/sunjce_provider.jar
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/sunmscapi.jar
	 %s/C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/zipfs.jar
Bootstrap ClassLoader

In the above Output, you can see the Application Class Loaders loads the Java class from the Project Directory and EXT jars from the EXT C:/Program%20Files/Java/jdk1.7.0_45/jre/lib/ext/ Folder

Why we need Custom ClassLoader?
Whenever a class is referenced in a java program it is loaded using JVM’s bootstrap class loader. This often becomes a problem when two different classes with same name and same package declaration are to be loaded. For example relying on JVM’s class loader one cannot load two different versions of the same JDBC driver. The work around to this problem is lies in making a custom class loader and loading classes directly from JAR archives.

Other Reasons

  1. Better Memory Management Unused modules can be removed which unloads the classes used by that module, which cleans up memory.
  2. Load classes from anywhere Classes can be loaded from anywhere, for ex, Database, Networks, or even define it on the fly.
  3. Runtime Reloading Modified Classes Allows you to reload a class or classes runtime by creating a child class loader to the actual class loader, which contains the modified classes.Hot Deployment
  4. Provides Modular architecture Allows to define multiple class loader allowing modular architecture.
  5. Support Versioning Supports different versions of class within same VM for different modules. Multiple Version Support
  6. Avoiding conflicts Clearly defines the scope of the class to within the class loader.
  7. Class loading mechanism forms the basis of Inversion of Control

Simple URL Class Loader
In the below example we are using URL Class Loading method to load the Classes from the JAR file.We can load Classes from File Based URL or Network Based URL
We can also load class from DB

SimpleClassLoader.java

public class SimpleClassLoader {
	public static void main(String[] args) {
		URL url;
        try {
            url = new URL("file:///D:/jars/helper.jar");
            URLClassLoader ucl = new URLClassLoader(new URL[]{url});
            Class clazz = ucl.loadClass("com.mugil.org.Helper");
            Object o = clazz.newInstance();
            Helper objHelper = (Helper)o;
            System.out.println(o.toString());
    		System.out.println(objHelper.getMessage());            
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
	}
}

Output

Helper Method
com.mugil.org.Helper@4631c43f

Note: In the above example you can see the Typecasting from Object to Helper which again makes the code tightly coupled and defeats the purpose of the class loader dynamically loads Java classes into the Java Virtual Machine. To resolve this issue we can use Interface which is loaded by application class loader with the implementing class loaded by our own class loader.

Account.java

public interface Account {
	public Integer getInterestRate(); 
}

SavingsAccount.java

public class SavingsAccount implements Account {
	@Override
	public Integer getInterestRate() {
		return 10;
	}
}

Implementation classes added to our JAR so it can be loaded by our Class Loader

D:\java\ClassLoaders\bin> jar cvf Accounts.jar com\mugil\org\SavingsAccount.class
added manifest
adding: com/mugil/org/SavingsAccount.class(in = 496) (out= 301)(deflated 39%)

CalculateInterest.java

public class CalculateInterest {
	public static void main(String[] args) 
	{
		URL url;
        try {
            url = new URL("file:///D:/jars/Accounts.jar");
            URLClassLoader ucl = new URLClassLoader(new URL[]{url});
            Class clazz = ucl.loadClass("com.mugil.org.SavingsAccount");
            Account o = (Account)clazz.newInstance();            
            System.out.println(o.toString());
    		System.out.println(o.getInterestRate());            
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
	}
}	

In the above code I can change the logic interest is calculated in the SavingsAccount and redeploy the JAR without taking effect in other parts of the program.

The above jar file could be loaded accross network by giving URL as below

.
.
URL url = new URL("http://localhost:8080/Accounts.jar");
.
.

Multiple version Support of Same JAR

Java bytecode is universal across platforms, you can use it to instrument classes on any system: a measure which methods are called, suppress security-critical calls, divert System.out accesses to your own custom logging routines, or perform advanced dynamic bug-testing routines.

	public static void main(String[] args) {
		try { 
            URL url1 = new URL("file:///D:/jars/Accounts1.jar"); 
            URLClassLoader ucl1 = new URLClassLoader(new URL[]{url1}); 
            Class clazz1 = Class.forName("com.mugil.org.SavingsAccount", true, ucl1);
            Account quote1 = (Account) clazz1.newInstance();

            URL url3 = new URL("file:///D:/jars/Accounts.jar");
            URLClassLoader ucl3 = new URLClassLoader(new URL[]{url3});
            Class clazz2 = Class.forName("com.mugil.org.SavingsAccount", true, ucl3);
            Account quote2 = (Account) clazz2.newInstance();

            System.out.printf("clazz1 == clazz2? %b\n", clazz1 == clazz2);
            System.out.printf("quote1.class == quote2.class? %b\n", quote1.getClass() == quote2.getClass());

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
	}

Output

clazz1 == clazz2? false
quote1.class == quote2.class? false

Functional interfaces have a single functionality to exhibit. For example, a Comparable interface with a single method compareTo is used for comparison purpose
Functional Interface is an interface which has one and only one abstract method. Apart from abstract method, it can have any number of default and static methods which have an implementation and are not abstract and overridden method from Object.These interfaces are also called Single Abstract Method Interfaces. Few Functional Interfaces are Comparable, Runnable and etc.

Example of Functional Interface

@FunctionalInterface
public interface MyFunctionalInterface 
{
	public void MethodOne(int i, double d);
} 
@FunctionalInterface
public interface MyFunctionalInterface 
{
	public void MethodOne(int i, double d);
	
	default boolean methodTwo(String value) 
	{
        return true;
  }
} 

@FunctionalInterface annotation is used to mark an interface as Functional Interface
not mandatory to use it. If the interface is annotated with @FunctionalInterface annotation and when we
try to have more than one abstract method, it throws the compiler error.

There are two ways the abstract method definition in the functional interface could be done

One is by Anonymous Inner class and other is by Lambda Expression

For example in Java, if we have to instantiate runnable interface anonymously, then our code looks like below. It’s bulky

Anonymous Inner class way of method definion for Functional Interface

Runnable r = new Runnable(){
 @Override
 public void run() 
 {
	System.out.println("My Runnable");
 }};

lambda expressions for the above method implementation is

Lambda Expressions way of method definion for Functional Interface

Runnable r1 = () -> {
 System.out.println("My Runnable");
};

Functional interface with abstract method(oneMethod) and default(getMulty), static methods(getSum) which have an implementation and are not abstract and methods overridden from Object Class(toString and equals).

@FunctionalInterface
public interface MyFunctionalInterface 
{
	public void oneMethod(int i, double d);
	public String toString();
	public boolean equals(Object o);

	public static int getSum(int a,int b)
        {// valid->method static
		return a+b;
	}

	public default int getMulty(int c,int d)
        {//valid->method default
		return c+d;
        }
}

Functional Interface could be classified into the following 5 Types based on the parameters and the way the abstract method behaves

  1. Supplier
  2. Consumer
  3. Predicate
  4. Function
  5. Operator
Functional Interface Parameter Types Return Type Abstract Method Name Description
Runnable none void run Runs an action without arguments or return value
Supplier
none T get Supplies a value of type T
Consumer
T void accept Consumes a value of type T
BiConsumer
T, U void accept Consumes values of types T and U
Function
T R apply A function with argument of type T
BiFunction
T, U R apply A function with arguments of types T and U
UnaryOperator
T T apply A unary operator on the type T
BinaryOperator
T, T T apply A binary operator on the type T
Predicate
T boolean test A Boolean-valued function
BiPredicate
T, U boolean test A Boolean-valued function with two arguments

When Memory Leaks happen in Java

Objects inaccessible by running code but still stored in memory

Class allocates a large chunk of memory (e.g. new byte[1000000]), stores a strong reference to it in a static field, and then stores a reference to itself in a ThreadLocal. Allocating the extra memory is optional (leaking the Class instance is enough), but it will make the leak work that much faster.

Static field holding object reference

class MemorableClass 
{
    static final ArrayList list = new ArrayList(100);
}

Calling String.intern() on lengthy String

String str=readString(); // read lengthy string any source db,textbox/jsp etc..
// This will place the string in memory pool from which you can't remove
str.intern();

Unclosed open streams ( file , network etc… )

try {
    BufferedReader br = new BufferedReader(new FileReader(inputFile));
    ...
    ...
} catch (Exception e) {
    e.printStacktrace();
}

Unclosed connections

try {
    Connection conn = ConnectionFactory.getConnection();
    ...
    ...
} catch (Exception e) {
    e.printStacktrace();
}

The thread clears all references to the custom class or the ClassLoader it was loaded from.

When the clone method is invoked upon an array, it returns a reference to a new array which contains (or references) the same elements as the source array.

So in your example, int[] a is a separate object instance created on the heap and int[] b is a separate object instance created on the heap. (Remember all arrays are objects).

    int[] a = {1,2,3};
    int[] b = a.clone();

    System.out.println(a == b ? "Same Instance":"Different Instance");
    //Outputs different instance

If were to modify int[] b the changes would not be reflected on int[] a since the two are separate object instances.

b[0] = 5;
    System.out.println(a[0]);
    System.out.println(b[0]);
    //Outputs: 1
    //         5

This becomes slightly more complicated when the source array contains objects. The clone method will return a reference to a new array, which references the same objects as the source array.

class Dog{

        private String name;

        public Dog(String name) {
            super();
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

    }

Lets create and populate an array of type Dog

Dog[] myDogs = new Dog[4];

    myDogs[0] = new Dog("Wolf");
    myDogs[1] = new Dog("Pepper");
    myDogs[2] = new Dog("Bullet");
    myDogs[3] = new Dog("Sadie");

Clone dog

    Dog[] myDogsClone = myDogs.clone();


System.out.println(myDogs[0] == myDogsClone[0] ? "Same":"Different");
    System.out.println(myDogs[1] == myDogsClone[1] ? "Same":"Different");
    System.out.println(myDogs[2] == myDogsClone[2] ? "Same":"Different");
    System.out.println(myDogs[3] == myDogsClone[3] ? "Same":"Different");

This means if we modify an object accessed through the cloned array, the changes will be reflected when we access the same object in the source array, since they point to the same reference.

myDogsClone[0].setName("Ruff"); 
    System.out.println(myDogs[0].getName());
    //Outputs Ruff

changes to the array itself will only affect that array.

myDogsClone[1] = new Dog("Spot");
    System.out.println(myDogsClone[1].getName());
    System.out.println(myDogs[1].getName());
    //Outputs Spot
    //Pepper

As you see above the change in the child by assigning a new Dog does not have any impact on the parent because the reference itself is changed instead of change in the reference value.

Object cloning refers to creation of shallow copy of an object.

Why we Need Clone?

// Java program to demonstrate that assignment
// operator only creates a new reference to same
// object.
import java.io.*;
 
// A test class whose objects are cloned
class Test
{
    int x, y;
    Test()
    {
        x = 10;
        y = 20;
    }
}
 
// Driver Class
class Main
{
    public static void main(String[] args)
    {
         Test ob1 = new Test();
 
         System.out.println(ob1.x + " " + ob1.y);
 
         // Creating a new reference variable ob2
         // pointing to same address as ob1
         Test ob2 = ob1;
 
         // Any change made in ob2 will be reflected
         // in ob1
         ob2.x = 100;
 
         System.out.println(ob1.x+" "+ob1.y);
         System.out.println(ob2.x+" "+ob2.y);
    }
}

output

10 20
100 20
100 20

In Java, we can create only copy of reference variable and not the object.

How to Use Clone?

  1. class that implements clone() should call super.clone() to obtain the cloned object reference
  2. the class must also implement java.lang.Cloneable interface whose object clone we want to create otherwise it will throw CloneNotSupportedException when clone method is called on that class’s object.
  3.   protected Object clone() throws CloneNotSupportedException
    
// A Java program to demonstrate shallow copy
// using clone()
import java.util.ArrayList;
 
// An object reference of this class is
// contained by Test2
class Test
{
    int x, y;
}
 
// Contains a reference of Test and implements
// clone with shallow copy.
class Test2 implements Cloneable
{
    int a;
    int b;
    Test c = new Test();
    public Object clone() throws
                   CloneNotSupportedException
    {
        return super.clone();
    }
}
 
// Driver class
public class Main
{
    public static void main(String args[]) throws
                          CloneNotSupportedException
    {
       Test2 t1 = new Test2();
       t1.a = 10;
       t1.b = 20;
       t1.c.x = 30;
       t1.c.y = 40;
 
       Test2 t2 = (Test2)t1.clone();
 
       // Creating a copy of object t1 and passing
       //  it to t2
       t2.a = 100;
 
       // Change in primitive type of t2 will not
       // be reflected in t1 field
       t2.c.x = 300;
 
       // Change in object type field will be
       // reflected in both t2 and t1(shallow copy)
       System.out.println(t1.a + " " + t1.b + " " +
                          t1.c.x + " " + t1.c.y);
       System.out.println(t2.a + " " + t2.b + " " +
                          t2.c.x + " " + t2.c.y);
    }
}

output

10 20 300 40
100 20 300 40

How to Achieve Deep Copy

// A Java program to demonstrate deep copy
// using clone()
import java.util.ArrayList;
 
// An object reference of this class is
// contained by Test2
class Test
{
    int x, y;
}
 
 
// Contains a reference of Test and implements
// clone with deep copy.
class Test2 implements Cloneable
{
    int a, b;
 
    Test c = new Test();
 
    public Object clone() throws
                CloneNotSupportedException
    {
        // Assign the shallow copy to new refernce variable t
        Test2 t = (Test2)super.clone();
 
        t.c = new Test();
 
        // Create a new object for the field c
        // and assign it to shallow copy obtained,
        // to make it a deep copy
        return t;
    }
}
 
public class Main
{
    public static void main(String args[]) throws
                             CloneNotSupportedException
    {
       Test2 t1 = new Test2();
       t1.a = 10;
       t1.b = 20;
       t1.c.x = 30;
       t1.c.y = 40;
 
       Test2 t3 = (Test2)t1.clone();
       t3.a = 100;
 
       // Change in primitive type of t2 will not
       // be reflected in t1 field
       t3.c.x = 300;
 
       // Change in object type field of t2 will not
       // be reflected in t1(deep copy)
       System.out.println(t1.a + " " + t1.b + " " +
                          t1.c.x + " " + t1.c.y);
       System.out.println(t3.a + " " + t3.b + " " +
                          t3.c.x + " " + t3.c.y);
    }
}

output

10 20 30 40
100 20 300 0

When to use Clone?

  1. We should use clone to copy arrays because that’s generally the fastest way to do it.

Disadvantages of Clone Method

  1. Cloneable interface lacks the clone() method. Actually, Cloneable is a marker interface and doesn’t have any methods in it, and we still need to implement it just to tell the JVM that we can perform clone() on our object.
  2. Object.clone() is protected, so we have to provide our own clone() and indirectly call Object.clone() from it.
  3. If we are writing a clone method in a child class, e.g. Person, then all of its superclasses should define the clone() method in them or inherit it from another parent class. Otherwise, the super.clone() chain will fail.
  4. We can not manipulate final fields in Object.clone() because final fields can only be changed through constructors. In our case, if we want every Person object to be unique by id, we will get the duplicate object if we use Object.clone() because Object.clone() will not call the constructor, and final id field can’t be modified from Person.clone().

There are two effective ways to create copy of object

  1. Copy Constructor – Refer here
  2. Serialization- Refer Here

Even copy constructor has its disadvantage since working with the internal object(Child Objects) may make it inconsistent and fragile

31.How will you make a HashMap of Unique Objects(Object with same Attributes should not be added more than once) or Mutable class does not allow override of HashCode and Equals?

If two objects are same then they must return same value in hashcode() and equals() method whenever invoked.It is not necessary that two different object must have different hashcode values. it might be possible that they share common hash bucket.

JVM assigns unique hashcode value to each object when they are created in memory and if developers don’t override the hashcode method then there is no way the two object returns same hashcode value.

Without HashCode

package com.mugil.org.qs;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Question31 
{
	public static void main(String[] args) 
	{
		Map hmStudents = new HashMap();
		
		Student objStudent1 = new Student();
		objStudent1.setName("Abdul");
		objStudent1.setAge(23);
		
		hmStudents.put(objStudent1, "Playboy");
		
		Student objStudent2 = new Student();
		objStudent2.setName("Joseph");
		objStudent2.setAge(23);
		
		hmStudents.put(objStudent2, "Upcoming Playboy");
		
		
		Student objStudent4 = new Student();
		objStudent4.setName("Joseph");
		objStudent4.setAge(23);
		
		hmStudents.put(objStudent4, "Playboy");
		
		
		Iterator it = hmStudents.entrySet().iterator();
		
	    while (it.hasNext()) 
	    {
	        Map.Entry pair = (Map.Entry)it.next();
	        System.out.println(((Student)pair.getKey()).getName() + " = " + pair.getValue());
	        
	    }
	}
}

class Student
{
	String Name;
	Integer Age;
	
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	public Integer getAge() {
		return Age;
	}
	public void setAge(Integer age) {
		Age = age;
	}	
}

Output
Joseph = Playboy
Abdul = Playboy
Joseph = Upcoming Playboy

With HashCode Object with same value gets replaced

class Student
{
	String Name;
	Integer Age;
	
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	public Integer getAge() {
		return Age;
	}
	public void setAge(Integer age) {
		Age = age;
	}
	
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((Age == null) ? 0 : Age.hashCode());
		result = prime * result + ((Name == null) ? 0 : Name.hashCode());
		return result;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (Age == null) {
			if (other.Age != null)
				return false;
		} else if (!Age.equals(other.Age))
			return false;
		if (Name == null) {
			if (other.Name != null)
				return false;
		} else if (!Name.equals(other.Name))
			return false;
		return true;
	}	
}

Output
Joseph = Playboy
Abdul = Playboy

32.Why List<Parent> is not same as List<Child> ?
Let’s say we allow a List to be a subtype of List.Consider the following example:We allow a List to be a subtype of List. Consider the following example:

   List<String> stringList = new ArrayList<String>;
   List<Object> objectList = stringList; //this does compile only if List<String> where subtypes of List<Object>
   objectList.add(new Object());
   String s = stringList.get(0);// attempt to assign an Object to a String and the Java compiler has to prevent these cases.

In the above code you can see adding Parent and Child class within the same List may result in scenario where you wont be
able to guess whether its a Parent or Child.

If Foo is a subtype (subclass or subinterface) of Bar, and G is some generic type declaration, it is not the case that G is a subtype of G.

It’s useful to make comparison to arrays.
List is not subclass of List But Dog[] is subclass of Animal[]
Arrays are reifiable and covariant. Reifiable means their type information is fully available at runtime. Therefore arrays provide runtime type safety but not compile-time type
safety.

   // All compiles but throws ArrayStoreException at runtime at last line
    Dog[] dogs = new Dog[10];
    Animal[] animals = dogs; // compiles
    animals[0] = new Cat(); // throws ArrayStoreException at runtime

It’s vice versa for generics:Generics are erased and invariant. Therefore generics can’t provide runtime type safety, but they provide compile-time type safety.
In the code below if generics were covariant it will be possible to make heap pollution at line 3.

    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = dogs; // compile-time error, otherwise heap pollution
    animals.add(new Cat());

 

33.What is the difference between instanceof and getclass()
instanceof tests whether the object reference on the left-hand side (LHS) is an instance of the type on the right-hand side (RHS) or some subtype.
getClass() == … tests whether the types are identical.

34.What are different reference types in java

  1. Strong References : We can create an object and then assign it to a reference. Note that if the object has a strong reference, this object is never be garbage collected.
    MyClass obj = new MyClass ();  
    
  2. Weak References :This type of reference is used in WeakHashMap to reference the entry objects.If JVM detects an object with only weak references (i.e. no strong or soft references linked to any object object), this object will be marked for garbage collection.
  3. Soft References :even if the object is free for garbage collection then also its not garbage collected, until JVM is in need of memory badly.The objects gets cleared from the memory when JVM runs out of memory
  4. Phantom References :A special reference which says that the object was already finalized, and the garbage collector is ready to reclaim its memory.Before removing them from the memory, JVM puts them in a queue called ‘reference queue’ . They are put in a reference queue after calling finalize() method on them

35.Difference betwen connection timeout and socket timeout?
A connection timeout is the maximum amount of time that the program is willing to wait to setup a connection to another process.A connection timeout occurs only upon starting the TCP connection. This usually happens if the remote machine does not answer. This means that the server has been shut down, you used the wrong IP/DNS name or the network connection to the server is down.
A socket timeout is the timeout when waiting for individual packets. A socket timeout is dedicated to monitor the continuous incoming data flow. If the data flow is interrupted for the specified timeout the connection is regarded as stalled/broken. if you have a socket timeout of 1 second, and a response comprised of 3 IP packets, where each response packet takes 0.9 seconds to arrive, for a total response time of 2.7 seconds, then there will be no timeout.

36.Why we need to do serialization when the same can be done by using file streams?
Serialized objects maintain state in space, they can be transferred over the network, file system, etc
you could save your data to a text file on the computer, then have a program that reads that info, and based on the file, you could have your
program respond differently. if you use Serializable then you can easily load your Object graph to memory. For example you have a Student class
which have a Deportment. So if you serialize your Student then the Department also be saved.

Serializing on the other hand, puts things directly into computer language. It’s like you’re telling a Spanish computer something in Spanish, rather than telling it something in French, forcing it to learn French, then save things into its native Spanish by translating everything.
Serialization is also faster, because in Java, objects are handled on the heap, and take much longer than if they were represented as primitives on the stack.

37.What is Functional Interface?
Functional interfaces have a single functionality to exhibit. For example, a Comparable interface with a single method compareTo is used for comparison purpose
Functional Interface is an interface which has one and only one abstract method. Apart from abstract method it can have any number of default and static methods which have an implementation and are not abstract and overriden method from Object.These interfaces are also called Single Abstract Method Interfaces. Few Functional Interfaces are Comparable, Runnable etc.More details here

38.What are marker interfaces?
Marker Interface in java is an interface with no fields or methods within it. It is used to convey to the JVM that the class implementing an interface of this category will have some special behavior.

Few Marker interface are as below

  1. Searilizable interface
  2. Cloneable interface
  3. Remote interface used for RMI
  4. ThreadSafe interface

Marker interface in Java e.g. Serializable, Clonnable, and Remote are used to indicate something to compiler or JVM that the class implementing any of these would have some special behavior. Hence, if the JVM sees a Class is implementing the Serializable interface it does some special operation on it and writes the state of the object into object stream. This object stream is then available to be read by another JVM. Similarly, if JVM finds that a class is implementing Cloneable interface, it performs some special operation in order to support cloning.

Q1:What would be the output for the following Program?

Output:

True
False
False

Question1.java

public class Question1 
{
	public static void main(String[] args) 
	{
		String Name1 = "Mugil";
		String Name2 = "Mugil";
		String Name3 = new String("Mugil");
		String Name4 = new String("Mugil");
		
		System.out.println(Name1 == Name2);
		System.out.println(Name2 == Name3);
		System.out.println(Name3 == Name4);
	}
}

Output

true
false
false

Q2: there is a arraylist with Employee objects in it. The list contains duplicate Employee objects, Now i need to remove the duplicate objects from the list.how do you do that?
Override equals and hashcode and use equals method to compare two objects.If the class is coming from jar or uneditable use extends and override the hashcode and equals method
Question2.java

import java.util.ArrayList;
import java.util.List;

public class Question2 
{
	public static void main(String[] args) 
	{
		List<Employee> arrEmp = new ArrayList<Employee>();
		
		Employee objEmp1 = new Employee();
		objEmp1.setName("Mugil");
		objEmp1.setEmpId(101);
		
		Employee objEmp2 = new Employee();
		objEmp2.setName("Mugil");
		objEmp2.setEmpId(101);
		
		Employee objEmp3 = new Employee();
		objEmp3.setName("mugil");
		objEmp3.setEmpId(101);
		
		
		System.out.println("Both Object are Equal - " + objEmp1.equals(objEmp2));
		System.out.println("Both Object are Equal - " + objEmp3.equals(objEmp2));
		
	}
}

Question2.java

class Employee
{
	String Name;
	int EmpId;
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + EmpId;
		result = prime * result + ((Name == null) ? 0 : Name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (EmpId != other.EmpId)
			return false;
		if (Name == null) {
			if (other.Name != null)
				return false;
		} else if (!Name.equals(other.Name))
			return false;
		return true;
	}
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	public int getEmpId() {
		return EmpId;
	}
	public void setEmpId(int empId) {
		EmpId = empId;
	}
}

`

Output

Both Object are Equal - true
Both Object are Equal - false

Q3:What will happen if you call return or System.exit in try or catch block?Will finally block execute?
Scenario 1: Positive Scenario with no System.exit()

package com.mugil.org.qs;

public class Question3 
{
	public static void main(String[] args) 
	{	
		System.out.println(getName());		
	}
	
	public static String getName() 
	{
		try {
			return "Mugil";
		} catch (Exception e) {
			throw new NullPointerException("return value is null");
		}finally {
			System.out.println("Finally Block Executed");
		}
	}
}

Output

Finally Block Executed
Mugil

Scenario 2 :System.exit() in try block before exception

package com.mugil.org.qs;

public class Question3 
{
	public static void main(String[] args) 
	{	
		System.out.println(getName());		
	}
	
	public static String getName() 
	{
		try {
			System.exit(1);
			throw new NullPointerException("return value is null");
		} catch (Exception e) {
			throw new NullPointerException("return value is null");
		}finally {
			System.out.println("Finally Block Executed");
		}
	}
}

If the System.exit(1) is used after throw new NullPointerException then it compiler will complain for unreachable code.
Finally will not get executed
Output(Blank Screen)


Scenario 3 :System.exit() in catch block before exception

package com.mugil.org.qs;

public class Question3 
{
	public static void main(String[] args) 
	{	
		System.out.println(getName());		
	}
	
	public static String getName() 
	{
		try {			
			throw new NullPointerException("return value is null");
		} catch (Exception e) {
			System.exit(1);
			throw new NullPointerException("return value is null");
		}finally {
			System.out.println("Finally Block Executed");
		}
	}
}

Output(Blank Screen)


The only times finally won’t be called are

  1. If you invoke System.exit();
  2. If the JVM crashes first;
  3. If there is an infinite loop
  4. If the host system dies; e.g. power failure, hardware error

Q3a:What are parameters of System.exit?

  • Zero(0) – when execution went fine – Everything Okay
  • Positive(1-127) – Something I expected could potentially go wrong went wrong anticipated exception – (bad command-line, can’t find file, could not connect to server)
  • Negative(values greater than 128) – Something I didn’t expect at all went wrong (system error – unanticipated exception – externally forced termination e.g. kill -9)

Q4:What is the difference between Iterator and ListIterator
When you loop through list use listiterator since it is faster then iterator. It can traverse in both directions. Iterator can be used over collections whereas list iterator call be used only for list

When you are simple moving through List but you are not modifying the List object foreach is more efficient.In case you want to perform operations on each element of list individually taking out the element in such case use Iterator.

ListIterator Iterator
ListIterator to traverse List only Iterator is used for traversing List and Set both.
ListIterator, we can traverse a List in both the directions (forward and Backward). traverse in only forward direction using Iterator
We cannot obtain indexes while using Iterator We can obtain indexes at any point of time while traversing a list using ListIterator. The methods nextIndex() and previousIndex() are used for this purpose.
We can add element at any point of time while traversing a list using ListIterator. We cannot add element to collection while traversing it using Iterator, it throws ConcurrentModificationException when you try to do it.
By using set(E e) method of ListIterator we can replace the last element returned by next() or previous() methods. We cannot replace the existing element value when using Iterator.
Methods of ListIterator:

add(E e)
hasNext()
hasPrevious()
next()
nextIndex()
previous()
previousIndex()
remove()
set(E e)

Methods of Iterator:

hasNext()
next()
remove()

Q5:What would be the output of Following Program?

package com.mugil.org.qs;

public class Question4 
{
	public static void main(String[] args) 
	{
		my m = new my(){};
		m.myMethod();
		System.out.println(m.getClass().getSuperclass());
	}
}

abstract class my
{
	public void myMethod()
	{
		System.out.println("Abstract");
	}
}

Ans:The reason for this any anonymous class which has the same name as abstract class would be child class of the abstract class

Q6:Why we are unable to add primitives as generic type?

//Allowed
List<Integer> arrAges = new ArrayList<Integer>();

//Not allowed
List<int> arrAges = new ArrayList<int>();

Ans:This is to maintain backwards compatibility with previous JVM runtimes in the sense it could be referred by parent class instance Object

Q7: What would be the Output of following program

package com.mugil.org.qs;

public class Question7 
{
	public static void main(String[] args) {
		System.out.println(getSomeNumber());
	}
	
	public static int getSomeNumber()
	{
		try{
			throw new RuntimeException();			
		}finally{
			return 1;
		}
	}
}

Output

1

Ans: Finally will run at any cause other than system.exit() call.

Q7a: What would be the Output of following program

package com.mugil.org.qs;

public class Question7a 
{
	public static void main(String[] args) 
	{
		if(isQAAssured())
		  System.out.println("QA Checked");
		else
		  System.out.println("QA is not Checked");
	}
	
	public static boolean isQAAssured()
	{
		try 
		{
			return true;
		}
		finally 
		{
			return false;
		}
	}
}

Output

QA is not Checked

Q7a: What would be the Output of following program

package com.mugil.org.qs;

public class Question8 
{
	public static void main(String[] args) 
	{
		javaHungry(null);
	}

	public static void javaHungry(Integer s)
	{
		System.out.println("Integer");
	}
	
	public static void javaHungry(Object s)
	{
		System.out.println("Object");
	}
	
	public static void javaHungry(String s)
	{
		System.out.println("String");
	}
}

Output

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The method javaHungry(Integer) is ambiguous for the type Question8

Q8:The code wont compile since, To explain the things in details let have a look into the following code
Question8.java

package com.mugil.org.qs;

public class Question8 
{
	public static void main(String[] args) 
	{
		javaHungry(null);
	}

	/*public static void javaHungry(Integer s)
	{
		System.out.println("Integer");
	}*/
	
	public static void javaHungry(Object s)
	{
		System.out.println("Object");
	}
	
	public static void javaHungry(String s)
	{
		System.out.println("String");
	}
} 

Output

String

The reason the above code worked is java compiler tries to find out the method with most specific input parameters to invoke a method.We know that Object is the parent class of String, so the choice was easy. If more than one member method is both accessible and applicable to a method invocation … The Java programming language uses the rule that the most specific method is chosen.

Now when the same is used in the before code which has String and int.You will get compile time error as The method foo(Object) is ambiguous for the type Test because both String and Integer class have Object as parent class and there is no inheritance. So java compiler doesn’t consider any of them to be more specific, hence the method ambiguous call error.

What would be the output?

package com.mugil.org.qs;

public class Question8 
{
	public static void main(String[] args) 
	{
		callMe(null);
	}

	public static void callMe(Exception e) {
		System.out.println("Exception");
	}

	public static void callMe(NullPointerException ne) {
		System.out.println("NullPointerException");
	}

	
	public static void callMe(Object s)
	{
		System.out.println("Object");
	}
}

Output

NullPointerException

As above explained, here callMe(NullPointerException ne) is the most specific method because it’s inherited from Exception class and hence this code compiles fine and when executed prints “NullPointerException”.

What would be the output?

package com.mugil.org.qs;

public class Question9 
{
	public static void main(String[] args) 
	{
		System.out.println(methodOfA());
	}
	
	public static int methodOfA()
	{	
		return (true?null:1);
	}
}

Output

Exception in thread "main" java.lang.NullPointerException
	at com.mugil.org.qs.Question9.methodOfA(Question9.java:12)
	at com.mugil.org.qs.Question9.main(Question9.java:7)
  1. Now when you see the above code the first thing you notice is the code might throw compilation error.how a int can return a null.Whenever you return a primitive value from a method then it would be autoboxed to the wrapper type and sent back to calling method
  2. int is a primitive, null is not a value that it can take on. You could change the method return type to return java.lang.Integer and then you can return null, and existing code that returns int will get autoboxed.
  3. So the output would be runtimeexception that is NullPointerException

Q9:What would be the output?

package com.mugil.org.qs;

public class Question10 
{
	public static void main(String[] args) 
	{
		System.out.println("main1");
		main ("main2");
	}
	
	public static void main(String arg)
	{
	      System.out.println(arg);
	}
}

Output

main1
main2

Ans:Overloading static methods are allowed. Overloading is legal, Overriding is illegal since the static methods belong to a class and there could not be method with same name and parameters within the class

Q11:What would be the output?

package com.mugil.org.qs;

public class Question11 
{
	public static void main(String[] args) 
	{
		try 
		{
			printName();
			System.out.println("Inside Try Block");
		}
		catch (Exception e) 
		{
			System.out.println("Inside Exception Block");
		}
		finally 
		{
			System.out.println("Inside finally Block");
		}
	}
	
	public static void printName()
	{
		throw new Error();
	}
}

Output

Exception in thread "main" Inside finally Block
java.lang.Error
	at com.mugil.org.qs.Question11.printName(Question11.java:24)
	at com.mugil.org.qs.Question11.main(Question11.java:9)

Ans:-Control will go inside finally and Inside finally Block would be printed despite error.

Q11:What would be the output?

package com.mugil.org.qs;

public class Question12 
{
	public static void main(String[] args) 
	{
		Animal[] arrAnimal = {new Animal(), new Dog(),new Animal()};
		
		for (int i = 0; i < arrAnimal.length; i++) 
		{
			arrAnimal[i].doStuff();
		}
	}
}


class Animal
{
	public static void doStuff()
	{
		System.out.println("Animal Stuff");
	}
}

class Dog extends Animal
{
	public static void doStuff()
	{
		System.out.println("Dog Stuff");
	}	
}

Output

Animal Stuff
Animal Stuff
Animal Stuff

Ans:-Since the methods are static it belongs to class not objects, the reference types are ignored and the calling type are considered. In our case Animal.

Q12:Why Fail fast are not thread safe where as fail safe are thread safe?
Concurrent Modification: Concurrent Modification in programming is to modify an object concurrently when another task is already running over it. For example, in Java to modify a collection when another thread is iterating over it. Some Iterator implementations may choose to throw ConcurrentModificationException if this behavior is detected.

Iterators in java are used to iterate over the Collection objects.Fail-Fast iterators immediately throw ConcurrentModificationException if there is structural modification of the collection. Structural modification means adding, removing or updating any element from collection while a thread is iterating over that collection. Iterator on ArrayList, HashMap classes are some examples of fail-fast Iterator.Fail-Safe iterators don’t throw any exceptions if a collection is structurally modified while iterating over it. This is because, they operate on the clone of the collection, not on the original collection and that’s why they are called fail-safe iterators. Iterator on CopyOnWriteArrayList, ConcurrentHashMap classes are examples of fail-safe Iterator.

To know whether the collection is structurally modified or not, fail-fast iterators use an internal flag called modCount which is updated each time a collection is modified.Fail-fast iterators checks the modCount flag whenever it gets the next value (i.e. using next() method), and if it finds that the modCount has been modified after this iterator has been created, it throws ConcurrentModificationException.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
 
public class FailFastExample {
    public static void main(String[] args)
    {
        Map<String, String> cityCode = new HashMap<String, String>();
        cityCode.put("Delhi", "India");
        cityCode.put("Moscow", "Russia");
        cityCode.put("New York", "USA");
 
        Iterator iterator = cityCode.keySet().iterator();
 
        while (iterator.hasNext()) {
            System.out.println(cityCode.get(iterator.next()));
 
            // adding an element to Map
            // exception will be thrown on next call
            // of next() method.
            cityCode.put("Istanbul", "Turkey");
        }
    }
}

Output

India
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.HashMap$HashIterator.nextNode(HashMap.java:1442)
    at java.util.HashMap$KeyIterator.next(HashMap.java:1466)
    at FailFastExample.main(FailFastExample.java:18)

Q13:What is Marshalling and Unmarshalling?
To marshall an object is to convert it into a form suitable for serialised storage or transmission; that is, to convert it from its native form within the JVM’s memory, into a form that could be sent down a wire, inserted into a file/database, etc. The specifics will vary depending on the form of marshalling involved; Java’s default serialisation mechanism is one way, but converting the object into an XML or JSON representation are equally valid.

Unmarshalling is just the reverse/other side of this process; taking a representation of the object created by marshalling, and using it to reconstitute an object instance within the JVM.

Q14:What will happen if we directly call run method?

class TestRunnable implements Runnable
{
    public static void main(String[] args)
    {
      TestRunnable nr = new TestRunnable();
      Thread t = new Thread(nr);
      t.setName("Fred");
      t.start();
    }

    public void run()
    {
      System.out.println("TestRunnable in " + Thread.currentThread().getName());
    }
}

Output if only start is called:

TestRunnable in Fred

Output if only run is called:

TestRunnable in main

Existing thread will stop it’s current execution and it will call the newly created thread for which you called run()

Q14:Why is char[] preferred over String for passwords?
Strings are immutable. That means once you’ve created the String, if another process can dump memory, there’s no way (aside from reflection) you can get rid of the data before garbage collection kicks in.Character arrays (char[]) can be cleared after use by setting each character to zero and Strings not. If someone can somehow see the memory image, they can see a password in plain text if Strings are used, but if char[] is used, after purging data with 0’s, the password is secure.With an array, you can explicitly wipe the data after you’re done with it. You can overwrite the array with anything you like, and the password won’t be present anywhere in the system, even before garbage collection.

Q15:Java is pass-by-value or pass-by-reference?
Java is pass-by-value.Value of reference(address) is passed as value.

public class Question13 
{
	public static void main(String[] args) 
	{
		Points objPoints = new Points();
		Question13 objQuestion13 = new Question13();
		objPoints.setPoint(10);
		
		System.out.println(objPoints.getPoint());
		objQuestion13.swap(objPoints);
		System.out.println(objPoints.getPoint());
		
		
		objQuestion13.swapValue(objPoints);
		System.out.println(objPoints.getPoint());
	}	
	
	public void swap(Points pobjPoints)
	{
		Points objPoints = new Points();
		objPoints.setPoint(30);
		pobjPoints = objPoints;
	}
	
	
	public void swapValue(Points pobjPoints)
	{	
		pobjPoints.setPoint(30);
	}
}


class Points
{
	Integer point;
	
	public Integer getPoint() {
		return point;
	}
	public void setPoint(Integer point) {
		this.point = point;
	}
}

Output

10
10
30
  1. In the above program in the swap method we are passing the reference as value.So inside swap method the reference is assigned to new value and nothing happens outside
  2. In the swapvalue method again reference is passed as parameter, but we change the value by setting the value inside the location, inside the container using the setter method. so the changes we do inside would be shown up outside

Q16:Why does StringBuffer/StringBuilder not override equals or hashCode?

String Name1=new String("Mugil");
		String Name2=new String("Mugil");
		
		Map<String, Integer> hmNames = new HashMap();
		hmNames.put(Name1, 30);
		hmNames.put(Name1, 48);
		
		for (Map.Entry<String,Integer> entry : hmNames.entrySet()) 
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());

Output

Key = Mugil, Value = 48
StringBuilder Name1 = new StringBuilder("Mugil");
		StringBuilder Name2 = new StringBuilder("Mugil");
		
		Map<StringBuilder, Integer> hmNames = new HashMap();
		hmNames.put(Name1, 30);
		hmNames.put(Name1, 25);
		
		for (Map.Entry<StringBuilder,Integer> entry : hmNames.entrySet()) 
           System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());

Output

Key = Mugil, Value = 25

overriding hashCode() for mutable objects, since modifying such an object that is used as a key in a HashMap could cause the stored value to be “lost.”.In other sense if you have overridden the hashcode then the class would become mutable like in first hashmap example where String becomes mutable incontext to hashMap.String are immutable, but when the same is used in hashMap it becomes mutable because strings having Same value despite having different memory locations replace the before string since they have hashcode and equals overridden in their class.

Q17:When do you prefer to use ibatis over hibernate
Hibernate works well for case Create/Update/Delete some complex domain entities.myBatis is great for fetch queries (case 2) where you just want an answer. Run analytic fetch queries (i.e. summation/aggregation queries).Hibernate would attempt to load the entire object graph and you’d need to start tuning queries with LazyLoading tricks to keep it working on a large domain. Conversely if you just want some analytic POJO page, the myBatis implementation of the same query would be trivial.

Q18:What is the difference between singleton scope in spring and singleton pattern?
One is scope of bean in spring container and another is design pattern, single object per jvm instance.

Q19:Why does Map interface not extend the Collection interface in the Java Collections Framework?
One of the reason is other than map, all the interfaces designed to store a single element. But map is storing the elements in the key value pair.So methods in Collection interface are incompatible for Map interface.Same argument goes for addAll(), remove(), removeAll() methods. So the main reason is the difference in the way data is stored in Map and Collections.

Q20:How to create a ArrayList of fixed size in java
Note the question again.The question is wrong.For arrayList we can only set the Capacity not Size.
Capacity is how many elements the list can potentially accommodate without reallocating its internal structures.When you call new ArrayList(10), you are setting the list’s initial capacity, not its size.Size is the number of elements in the list.So the question supposed to be how will you allocate arrayList with some number of capacity.

List<Integer> arr = new ArrayList<Integer>(10);
System.out.println(arr);
System.out.println(arr.size());

Output

[]
0

So from above code though the memory space for the arrayList has been allocated the size of the array is still 0.

Now I want to allocated ArrayList with Size 10 with initial values being 0 in that.

public static void main(String[] args) 
	{	
		ArrayList<Integer> arr = new ArrayList<Integer>(Collections.nCopies(10, 0));
		System.out.println(arr);
		System.out.println(arr.get(0));
	}

Output

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
0

Q21:Has anyone used ArrayBlockingQueue? How does it work ?
The ArrayBlockingQueue class implements the BlockingQueue interface. ArrayBlockingQueue is a bounded, blocking queue that stores the elements internally in an array. That it is bounded means that it cannot store unlimited amounts of elements. There is an upper bound on the number of elements it can store at the same time. You set the upper bound at instantiation time, and after that it cannot be changed.

BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1024);
queue.put("1");
String string = queue.take();

Q21:What is the significance of the attribute delete orphan in hibernate
DELETE_ORPHAN means if an entity is removed from a related one-to-many collection, then not only disassociate it from the current entity, but delete it.Lets take a Employee and Address Model.If you do a Cascade Delete in the Employee then the Employee rows would be removed from the Employee table and the association between the Address and the Employee is removed. The Row in Address table still exist and its a orphan record not referred. Now when you do delete orphan also this row in the address table would also be deleted.
de-associating the parent and child relation and then immediately delete orphan records from db.

Q22:What is difference between pojo and javabean?
Please Refer Answer

Q23: Difference between comparator and comparable?
Please Refer Here

Q24: What is coercion polymorphism in java
For example, you divide an integer by another integer or a floating-point value by another floating-point value. If one operand is an integer and the other operand is a floating-point value, the compiler coerces (implicitly converts) the integer to a floating-point value to prevent a type error. (There is no division operation that supports an integer operand and a floating-point operand.) Another example is passing a subclass object reference to a method’s superclass parameter. The compiler coerces the subclass type to the superclass type to restrict operations to those of the superclass.

Q25: What is double dispatching
please refer here

Q26: How does cocurrentmodification exception occur while modifying array list. To be precise based on which indicator
When we iterate through the same list and when we try to modify the same list … Then we get the concurrent modification exception …
Fail fast iterator is used for iteration so we get that error.There is an indicator called modcount which is checked inbetween every operation to make sure whether List is modified or not.

Q27: How will you copy object attributes from one object to another or how to create a object which has replica of all attributes from another object ?
Cloning is a process of creating an exact copy of an existing object in the memory. In java, clone() method of java.lang.Object class is used for cloning process. This method creates an exact copy of an object on which it is called through field-by-field assignment and returns the reference of that object. Not all the objects in java are eligible for cloning process. The objects which implement Cloneable interface are only eligible for cloning process. Cloneable interface is a marker interface which is used to provide the marker to cloning process

Shallow copy
The shallow copy of an object will have exact copy of all the fields of original object. If original object has any references to other objects as fields, then only references of those objects are copied into clone object, copy of those objects are not created. That means any changes made to those objects through clone object will be reflected in original object or vice-versa. Shallow copy is not 100% disjoint from original object. Shallow copy is not 100% independent of original object.

Deep Copy
Deep copy of an object will have exact copy of all the fields of original object just like shallow copy. But in additional, if original object has any references to other objects as fields, then copy of those objects are also created by calling clone() method on them. That means clone object and original object will be 100% disjoint. They will be 100% independent of each other. Any changes made to clone object will not be reflected in original object or vice-versa.

clone is tricky to implement correctly.It’s better to use Defensive copying, copy constructors or static factory methods.

Refer Here

Q28: While doing hashing we use to have prime numbers to perform modulo operation?even when u generate equals and hashcode in eclipse for ur class you would get 31 as divisor, culd someone explain this?
What is Prime Number
A number that is divisible only by itself and 1.Primes are unique numbers. They are unique in that, the product of a prime with any other number has the best chance of being unique due to the fact that a prime is used to compose it. This property is used in hashing functions.Given a string “Samuel”, you can generate a unique hash by multiply each of the constituent digits or letters with a prime number and adding them up. This is why primes are used.

Now why is 31 used?
Using a prime of 31 gives a better distribution to the keys, and lesser no of collisions. If you take over 50,000 English words (formed as the union of the word lists provided in two variants of Unix), using the constants 31, 33, 37, 39, and 41 will produce less than 7 collisions in each case.Using P(31), as it’s the cheapest to calculate (because 31 is the difference of two powers of two). P(33) is similarly cheap to calculate, but it’s performance is marginally worse, and 33 is composite(3*11=33)

Q29:You are thrown with a chained exception, now you need to find the root cause for the exception, which method will you use to get the actual cause for the exception?

Throwable getCause(Throwable e) {
    Throwable cause = null; 
    Throwable result = e;

    while(null != (cause = result.getCause())  && (result != cause) ) {
        result = cause;
    }
    return result;
}

Same using Recursion

public static Throwable getRootCause(Throwable throwable) {
    if (throwable.getCause() != null)
        return getRootCause(throwable.getCause());

    return throwable;
}

Using ApacheUtils

Throwable getRootCause(Throwable throwable) 
String getRootCauseMessage(Throwable th)