Saturday, 18 April 2015

Java Questions and anwsers

Keywords in java
Q1) What are different types of access modifiers in Java?
Ans) There are four different types of modifiers:
Modifer
Accessible in the same package
Accessible in different package
Private
No
No
Protected
Yes
Yes, only if the class extends the main class
Default
Yes
No
Public
Yes
Yes
Q2) What is the use of final keyword?
Ans) The final keyword can be assigned to
  1. Class level variable
  2. method
  3. class
  4. Objects
If a final is assigned to a variable, the variable behaves as a constant. It means that the value of variable once set cannot be changed.
final int i = 1;
i = 5; // error
If a final is assigned to a method then it cannot be overridden in its child class.
class Parent {
  final void  print(){
    System.out.println("Inside");
  }         
}
 
class Child extends Parent{
  public final void  print(){
   // error cannot  override final method
    System.out.println("Inside");
  }
}
If a class is made as final, then no other class can extend it and make it as parent class. E.g. String Class.
Final objects are instantiated only once. i.e
final Map map = new HashMap();
map.put("key";,"value");
map = new HashMap(); // error
Q3) What is use of synchronized keyword?
Ans) This keyword is used to prevent concurrency. Synchronized keyword can be applied to static/non-static methods or a block of code. Only one thread at a time can access synchronized methods and if there are multiple threads trying to access the same method then other threads have to wait for the execution of method by one thread. Synchronized keyword provides a lock on the object and thus prevents race condition. E.g.
public void synchronized method(){}
  public void synchronized staticmethod(){}
  public void myMethod(){
    synchronized (this){ // synchronized keyword on block  of code
    }
  }
Q4) What is volatile keyword?
Ans) In general each thread has its own copy of variable, such that one thread is not concerned with the value of same variable in the other thread. But sometime this may not be the case. Consider a scenario in which the count variable is holding the number of times a method is called for a given class irrespective of any thread calling, in this case irrespective of thread access the count has to be increased. In this case the count variable is declared as volatile. The copy of volatile variable is stored in the main memory, so every time a thread access the variable even for reading purpose the local copy is updated each time from the main memory. The volatile variable also have performance issues.
Q5) What is a transient variable?
Ans) If some of the properties of a class are not required to be serialized then the varaibles are marked as transient. When an object is deserialized the transient variables retains the default value depending on the type of variable declared and hence lost its original value.
Q6) What is a strictfp modifier?
Ans) Strictfp is used with variable only . It is used to restrict floating point calculations ( fp ) to ensure portability ( platform Independent ). When this modifier is specified, the JVM adheres to the Java specifications ( IEEE-754 floating-point specification ) and returns the consistent value independent of the platform. That is, if you want the answers from your code (which uses floating point values) to be consistent in all platforms, then you need to specify the strictfp modifier.
Q7) What is a static variable?
Ans) Static keyword can be used with the variables and methods but not with the class. Anything declared as static is related to class and not objects.
Static variable : Multiples objects of a class shares the same instance of a static variable.Consider the example:
public class Counter{
 private static int count=0;
 private int nonStaticcount=0;
 public void incrementCounter(){
   count++;
   nonStaticcount++;
 }
 public int getCount(){
  return count;
 }
 public int getNonStaticcount(){
  return nonStaticcount;
 }

 public static void main(String args[]){

   Counter countObj1 = new Counter();
   Counter countObj2 = new Counter();
   countObj1.incrementCounter();
   countObj1.incrementCounter();
   System.out.println("Static count for Obj1: "+countObj1.getCount());
   System.out.println("NonStatic count for Obj1: "+countObj1.getNonStaticcount());
   System.out.println("Static count for Obj2: "+countObj2.getCount())
   System.out.println("NonStatic count for Obj2: "+countObj2.getNonStaticcount())
 }
Output
Static count for Obj1: 2
NonStatic count for Obj1: 1
Static count for Obj2: 2
NonStatic count for Obj2: 1
In the above program obj1 and obj2 share the same instance of static variable count hence if the value is incremented by one object , the incremented value will be reflected across the other objects.
Q8) What is a static method?
Ans)A method defined as static is called static method. A static method can be accessed without creating the objects. Just by using the Class name the method can be accessed.
Static method can only access static variables and not local or global non-static variables. For eg:
public class Test{
 public static void printMe(){
 System.out.println("Hello World");
 }
}
public class MainClass{
 public static void main(String args[]){
  Test.printMe()

   }
 }

OutPut:
Hello World
Also static method can call only static methods and not non static methods. But non-static methods can call static mehtods.
Q9) Why static methods cannot access non static variables or methods?
Ans) A static method cannot access non static variables or methods because static methods can be accessed without instantiating the class, so if the class is not instantiated the variables are not intialized and thus cannot be accessed from a static method.
Q10) What is static class ?
Ans) A class cannot be declared static. But a class can be said a static class if all the variables and methods of the class are static and the constructor is private. Making the constructor private will prevent the class to be instantiated. So the only possibility to access is using Class name only
Q9) What is throw keyword?
Ans) Throw keyword is used to throw the exception manually. It is mainly used when the program fails to satisfy the given condition and it wants to warn the application.The exception thrown should be subclass of Throwable.
public void parent(){
    try{
        child();
        }catch(MyCustomException e){  }
    }
 
public void child{
  String iAmMandatory=null;
  if(iAmMandatory == null){
    throw (new MyCustomException("exception using throw keyword");
  }
}
Q10) What is use of throws keyword?
Ans) Throws clause is used to throw the exception from a method to the calling method which could decide to handle exception or throw to its calling method in a class.
 public void parent(){
  try{
      child();
      }catch(MyCustomException e){  }
  }

  public void child throws MyCustomException{
  //put some logic so that the exception occurs.
  }
Key Concepts in Java
Q1) Why is main() method static?
Ans) To access a static method class object is not needed. The method can be accessed directly with the help of ClassName. So when a program is started the jvm search for the class with main method and calls it without creating an object of the class.
Q2) What is the difference between static and instance methods?
Ans) instance method belongs to the instance of a class therefore it requires an instance before it can be invoked, whereas static method belongs to the class itself and not to any class instance so it doesn’t need an instance to be invoked.
Instance methods use dynamic (late) binding, whereas static methods use static (early) binding.
When the JVM invokes a class instance method, it selects the method to invoke based on the type of the object reference, which is always known at run-time. On the other hand, when the JVM invokes a static method, it selects the method to invoke based on the actual class of the object, which may only be known at compile time.
Q3) Can static block throw exception?
Ans) Yes, static block can throw only Runtime exception or can use a try-catch block to catch checked exception.
Typically scenario will be if JDBC connection is created in static block and it fails then exception can be caught, logged and application can exit. If System.exit() is not done, then application may continue and next time if the class is referred JVM will throw NoClassDefFounderror since the class was not loaded by the Classloader.
Q4) What is difference between abstract class and interface?
Ans)
  • A class is called abstract when it contains at least one abstract method. It can also contain n numbers of concrete method.Interface can contain only abstract( non implemented) methods.
  • The abstract class can have public,private,protect or default variables and also constants. In interface the variable is by default public final. In nutshell the interface doesnt have any variables it only has constants.
  • A class can extend only one abstract class but a class can implement multipleinterfaces.
  • If an interface is implemented its compulsory to implement all of its methods but if an abstract class is extended its not compulsory to implement all methods.
  • The problem with an interface is, if you want to add a new feature (method) in its contract, then you MUST implement those method in all of the classes which implement that interface. However, in the case of an abstract class, the method can be simply implemented in the abstract class and the same can be called by its subclass.
Q5) Explain with example to describe when to use abstract class and interface?
Ans) Consider a scenario where all Cars will have 4 tyres and other features can be different.
In this case any subclass of Car has to have 4 tyres. This is a case where abstract class will be used and a default implementaion for tyres will be provided.
public abstract class Car {
private final static TOTAL_TYRES=4;
public abstract String getCarName(); 
public final int getNoOfTyres(){
                                         return TOTAL_TYRES;
}
}
Consider a scenario where Cars can have any number of tyres and other features can also be different. In this case interface will be created.
public interface Car {
public abstract String getCarName();
public abstract int getNoOfTyres();
}
Q6) Does java support multiple interitance? Why?
Ans) Java doesnt support multiple inheritance but it provide a way through which it can enact it. Consider the scenario is C++
Class A {
public void add(){
                    // some text
}
}
Class B {
public void add(){
                    // some text
}
}
Class C extends A,B {
public static void main(String arg[]){
C objC = new C();
objC.add();  // problem, compiler gets confused and cant
decide to call Class A or B method.
}
This problem is called Diamond problem.

This problem in java is taken care with the use of interfaces
In Java similar problem would look like:

interface A{
add();
}
interface B{
add();
}
class C implements A,B{
add(){
// doesnt matter which interface it belong to
}
}
Q7) Can this keyword be assigned null value?
Ans) No
Q8) What are the different types of references in java?
Ans) Java has a more expressive system of reference than most other garbage-collected programming languages, which allows for special behavior for garbage collection. A normal reference in Java is known as a strong reference. The java.lang.ref package defines three other types of references—soft, weak and phantom references. Each type of reference is designed for a specific use.
A SoftReference can be used to implement a cache. An object that is not reachable by a strong reference (that is, not strongly reachable) but is referenced by a soft reference is called softly reachable. A softly reachable object may be garbage collected at the discretion of the garbage collector. This generally means that softly reachable objects will only be garbage collected when free memory is low, but again, it is at the discretion of the garbage collector. Semantically, a soft reference means "keep this object unless the memory is needed."
A WeakReference is used to implement weak maps. An object that is not strongly or softly reachable, but is referenced by a weak reference is called weakly reachable. A weakly reachable object will be garbage collected during the next collection cycle. This behavior is used in the class java.util.WeakHashMap. A weak map allows the programmer to put key/value pairs in the map and not worry about the objects taking up memory when the key is no longer reachable anywhere else. Another possible application of weak references is the string intern pool. Semantically, a weak reference means "get rid of this object when nothing else references it."
A PhantomReference is used to reference objects that have been marked for garbage collection and have been finalized, but have not yet been reclaimed. An object that is not strongly, softly or weakly reachable, but is referenced by a phantom reference is calledphantom reachable. This allows for more flexible cleanup than is possible with the finalization mechanism alone. Semantically, a phantom reference means "this object is no longer needed and has been finalized in preparation for being collected."
Q9) How to change the heap size of a JVM?
Ans) The old generation's default heap size can be overridden by using the -Xms and -Xmx switches to specify the initial and maximum sizes respectively:
java -Xms <initial size> -Xmx <maximum size> program
For example:
java -Xms64m -Xmx128m program
Q10) What is difference between instanceof and isInstance(Object obj)?
Ans) Differences are as follows:
1) instanceof is a reserved word of Java, but isInstance(Object obj) is a method of java.lang.Class.
2) instanceof is used of identify whether the object is type of a particular class or its subclass but isInstance(obj) is used to identify object of a particular class.
Q11) Java supports pass by value or pass by reference?
Ans) Java supports only pass by value. The arguments passed as a parameter to a method is mainly primitive data types or objects. For the data type the actual value is passed.
Java passes the references by value just like any other parameter. The pointer to the object is passed as value. Thus, method manipulation will alter the objects, since the references point to the original object but will not intialize the new object. Consider the example:
public void tricky(Point arg1, Point arg2) {
                    arg1.x = 100;
                    arg1.y = 100;
                    Point temp = arg1;
                    arg1 = arg2;
                    arg2 = temp;
}
public static void main(String [] args) {
                    Point pnt1 = new Point(0,0);
                    Point pnt2 = new Point(0,0);
                    System.out.println("X: " + pnt1.x + " Y: " +pnt1.y);
                    System.out.println("X: " + pnt2.x + " Y: " +pnt2.y);
                    System.out.println(" ");
                    tricky(pnt1,pnt2);
                    System.out.println("X: " + pnt1.x + " Y:" + pnt1.y);
                    System.out.println("X: " + pnt2.x + " Y: " +pnt2.y); 
}

OutPut:
X: 0 Y: 0
X: 0 Y: 0
X: 100 Y: 100
X: 0 Y: 0
The method successfully alters the value of pnt1, even though it is passed by value; however, a swap of pnt1 and pnt2 fails! This is the major source of confusion. In the main() method, pnt1 and pnt2 are nothing more than object references. When you pass pnt1 and pnt2 to the tricky() method, Java passes the references by value just like any other parameter. This means the references passed to the method are actually copies of the original references.
Q12) What is memory leak?
Ans) A memory leak is where an unreferenced object that will never be used again still hangs around in memory and doesnt get garbage collected.
Q13) What is the difference between equals() and ==?
Ans) == operator is used to compare the references of the objects.
public bollean equals(Object o) is the method provided by the Object class. The default implementation uses == operator to compare two objects. But since the method can be overriden like for String class. equals() method can be used to compare the values of two objects.
String str1 = "MyName";
String str2 = "MyName";
String str3 = str2;

if(str1 == str2){
System.out.println("Objects are equal")
}else{
System.out.println("Objects are not equal")
}
if(str1.equals(str2)){
System.out.println("Objects are equal")
}else{
System.out.println("Objects are not equal")
}

Output:
Objects are not equal
Objects are equal
String str2 = "MyName";
String str3 = str2;
if(str2 == str3){
System.out.println("Objects are equal")
}else{
System.out.println("Objects are not equal")
}
if(str3.equals(str2)){
System.out.println("Objects are equal")
}else{
System.out.println("Objects are not equal")
}

Output:
Objects are equal
Objects are equal
Keyconcepts in java
Q16) Can an abstract class have a static method?
Ans) Yes an abstract class have a static method and it can be accessed by any other class(even not a concrete class).
Q17) Can an abstract class have a constructor?
Ans) Yes an abstract class have a default and parameterized constructors.
Q18) Why static methods cannot access non static variables or methods?
Ans) A static method cannot access non static variables or methods because static methods doesnt need the object to be accessed. So if a static method has non static variables or non static methods which has instantiated variables they will no be intialized since the object is not created and this could result in an error.
Q19) What is difference between stringbuffer and stringbuilder?
Ans) The only difference between StringBuffer and StringBuilder is that StringBuilder is unsynchronized whereas StringBuffer is synchronized. So when the application needs to be run only in a single thread then it is better to use StringBuilder. StringBuilder is more efficient than StringBuffer.
Criteria to choose among StringBuffer and StringBuilder
  • If your text can change and will only be accessed from a single thread, use a StringBuilder 2)because StringBuilder is unsynchronized.
  • If your text can changes, and will be accessed from multiple threads, use a StringBuffer because StringBuffer is synchronous.
Q20) Consider a scenario in which the admin want to sure that if some one has written System.exit() at some part of application then before system shutdown all the resources should be released. How is it possible?
Ans) This is possible using Runtime.getRuntime().addShutdownHook(Thread hook).
Straight from Java Spec:
This method registers a new virtual-machine shutdown hook.
The Java virtual machine shuts down in response to two kinds of events:
  • The program exits normally, when the last non-daemon thread exits or when the exit (equivalently, System.exit) method is invoked.
  • The virtual machine is terminated in response to a user interrupt, such as typing ^C, or a system-wide event, such as user logoff or system shutdown.
A shutdown hook is simply an initialized but unstarted thread. When the virtual machine begins its shutdown sequence it will start all registered shutdown hooks in some unspecified order and let them run concurrently. When all the hooks have finished it will then run all uninvoked finalizers if finalization-on-exit has been enabled. Finally, the virtual machine will halt. Note that daemon threads will continue to run during the shutdown sequence, as will non-daemon threads if shutdown was initiated by invoking the exit method.
Once the shutdown sequence has begun it can be stopped only by invoking the halt method, which forcibly terminates the virtual machine.
Q21) What is the difference between final, finally and finalize() in Java?
Ans) final - declaread as constant. A final variable act as constant, a final class is immutable and a final method cannot be ovrriden.
finally - handles exception. The finally block is optional and provides a mechanism to clean up regardless of what happens within the try block (except System.exit(0) call). Use the finally block to close files or to release other system resources like database connections, statements etc.
finalize() - method helps in garbage collection. A method that is invoked before an object is discarded by the garbage collector, allowing it to clean up its state. Should not be used to release non-memory resources like file handles, sockets, database connections etc because Java has only a finite number of these resources and you do not know when the garbage collection is going to kick in to release these non-memory resources through the finalize() method.
Q22) How does Java allocate stack and heap memory?
Ans) Each time an object is created in Java it goes into the part of memory known asheap. The primitive variables like int and double are allocated in the stack, if they are local method variables and in the heap if they are member variables (i.e. fields of a class). In Java methods local variables are pushed into stack. When a method is invoked and stack pointer is decremented when a method call is completed.
In a multi-threaded application each thread will have its own stack but will share the same heap. This is why care should be taken in your code to avoid any concurrent access issues in the heap space. The stack is threadsafe (each thread will have its own stack) but the heap is not threadsafe unless guarded with synchronisation through your code.
Q23) Explain re-entrant, recursive and idempotent methods/functions?
Ans) A method in stack is re-entrant allowing multiple concurrent invocations that do not interfere with each other.
A function is recursive if it calls itself. Given enough stack space, recursive method calls are perfectly valid in Java though it is tough to debug. Recursive functions are useful in removing iterations from many sorts of algorithms. Allrecursive functions are re-entrant but not all re-entrant functions are recursive. Idempotent methods are methods, which are written in such a way that repeated calls to the same method with the same arguments yield same results. For example clustered EJBs, which are written with idempotent methods, can automatically recover from a server failure as long as it can reach another server.
Q24)Can a private variable or method of a class can be accessed?
Ans) Yes its possible using reflection.
Q25)What is difference between static block and the init block?
Ans) The static block is loaded when the class is loaded by the JVM for the 1st time only whereas init {} block is loaded every time class is loaded. Also first the static block is loaded then the init block.
public class LoadingBlocks {

  static{
    System.out.println("Inside static");
  }
 
  {
    System.out.println("Inside init");
  }
  public static void main(String args[]){
    new LoadingBlocks();
    new LoadingBlocks();
    new LoadingBlocks();
  }
}

Output:

Inside static
Inside init
Inside init
Inside init
Q26)Why inner class can access only final variable?
Ans) Local classes can most definitely reference instance variables. The reason they cannot reference non final local variables is because the local class instance can remain in memory after the method returns. When the method returns the local variables go out of scope, so a copy of them is needed. If the variables weren't final then the copy of the variable in the method could change, while the copy in the local class didn't, so they'd be out of synch.
Anonymous inner classes require final variables because of the way they are implemented in Java. An anonymous inner class (AIC) uses local variables by creating a private instance field which holds a copy of the value of the local variable. The inner class isn't actually using the local variable, but a copy. It should be fairly obvious at this point that a "Bad Thing"â„¢ can happen if either the original value or the copied value changes; there will be some unexpected data synchronization problems. In order to prevent this kind of problem, Java requires you to mark local variables that will be used by the AIC as final (i.e., unchangeable). This guarantees that the inner class' copies of local variables will always match the actual values.
Q27)What is fully abstract class?
Ans) An abstract class which has all methods as abstract and all fields are public static final.
Q28)What is dynamic binding and static binding?
Ans) Method invocation
The Java programming language provides two basic kinds of methods: instance methods and class (or static) methods. The differences are:
1. Instance methods require an instance before they can be invoked, whereas class methods do not.
2. Instance methods use dynamic (late) binding, whereas class methods use static (early) binding.
When the Java virtual machine invokes a class method, it selects the method to invoke based on the type of the object reference, which is always known at compile-time. On the other hand, when the virtual machine invokes an instance method, it selects the method to invoke based on the actual class of the object, which may only be known at run time.
Q29) What is Java Reflection?
Ans)Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine.
Drawbacks of Reflection: Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.
Performance Overhead: Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.
Security Restrictions: Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.
Exposure of Internals: Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.
Q30) When an obj is passed through a function , one can set the properties but cannot set a new memory location?
Ans) It is because when u pass an object the address value is passed and stored in some new address . like if address 1234 is passed , it is stored in 4567 location. So if u change in the value of an object it will take the address from 4567 and do 1234.setXXX(). If u set the object to null it will set 4567=null.
OOPS concept interview questions
Q1) What is polymorphism?
Ans) The abiltiy to define a function in multiple forms is called Polymorphism. In java, c++ there are two type of polymorphism: compile time polymorphism (overloading) and runtime polymorphism (overriding).
Mehtod overriding: Overriding occurs when a class method has the same name and signature as a method in parent class. When you override methods, JVM determines the proper methods to call at the program’s run time, not at the compile time.
Overloading: Overloading is determined at the compile time. It occurs when several methods have same names with:
  • Different method signature and different number or type of parameters.
  • Same method signature but different number of parameters.
  • Same method signature and same number of parameters but of different type
Example of Overloading
int add(int a,int b)
 float add(float a,int b)
 float add(int a ,float b)
 void add(float a)
 int add(int a)
 void add(int a) //error conflict with the  method int add(int a)
class BookDetails {
String title;
setBook(String title){}
}
class ScienceBook extends BookDetails{
setBook(String title){} //overriding
setBook(String title, String publisher,float price){} //overloading
}
Q2) What is inheritance?
Ans) Inheritance is the property which allows a Child class to inherit some properties from its parent class. In Java this is achieved by using extends keyword. Only properties with access modifier public and protected can be accessed in child class.
public class Parent {
  public String parentName; 
  public String familyName;

  protected void printMyName() {
    System.out.println(“ My name is “+ chidName+” “ +familyName);
  }
}
public class Child extends Parent {
  public String childName;
  public int childAge;
  //inheritance
  protected void printMyName() {
    System.out.println(“ My child name is “+ chidName+” “ +familyName);
  }
}
In above example the child has inherit its family name from the parent class just by inheriting the class. When child object is created printMyName() present in child class is called.
Q3) What is multiple inheritance and does java support?
Ans) If a child class inherits the property from multiple classes is known as multiple inheritance. Java does not allow to extend multiple classes, to overcome this problem it allows to implement multiple Interfaces.

Q4) What is an abstraction ?
Ans) Abstraction is a way of converting real world objects in terms of class. Its a concept of defining an idea in terms of classes or interface. For example creating a class Vehicle and injecting properties into it. E.g
public class Vehicle {
  public String colour;
  public String model;
}
Q5) What is Encapsulation?
Ans) The encapsulation is achieved by combining the methods and attribute into a class. The class acts like a container encapsulating the properties. The users are exposed mainly public methods.The idea behind is to hide how thinigs work and just exposing the requests a user can do.
Q6) What is Association?
Ans) Association is a relationship where all object have their own lifecycle and there is no owner. Let’s take an example of Teacher and Student. Multiple students can associate with single teacher and single student can associate with multiple teachers but there is no ownership between the objects and both have their own lifecycle. Both can create and delete independently.
Q7) What is Aggregation?
Ans) Aggregation is a specialize form of Association where all object have their own lifecycle but there is ownership and child object can not belongs to another parent object. Let's take an example of Department and teacher. A single teacher can not belongs to multiple departments, but if we delete the department teacher object will not destroy. We can think about "has-a" relationship.
Q8) What is Composition ?
Ans) Composition is again specialize form of Aggregation and we can call this as a "death" relationship. It is a strong type of Aggregation. Child object dose not have their lifecycle and if parent object deletes all child object will also be deleted. Let's take again an example of relationship between House and rooms. House can contain multiple rooms there is no independent life of room and any room can not belongs to two different house if we delete the house room will automatically delete.
Java Collections Interview Questions

Java collections offers some of the most comprehnesive suite of built in Data structures. Often this is most common topic amongst interviewers. Good foundation and understanding of java collections helps to program effectively.
Q1) What is difference between ArrayList and vector?
Ans)
  • Synchronization - ArrayList is not thread-safe whereas Vector is thread-safe. In Vector class each method like add(), get(int i) is surrounded with a synchronized block, thus making Vector class thread-safe.
  • Data growth - Internally, both the ArrayList and Vector hold onto their contents using an Array. When an element is inserted into an ArrayList or a Vector, the object will need to expand its internal array if it runs out of room. A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent.
  • Performance - Since vector is thread-safe, the performance is slower than ArrayList.
Q2) How can Arraylist be synchronized without using Vector?
Ans) Arraylist can be synchronized using:
Collection.synchronizedList(List list)
  Other collections can be synchronized:
  Collection.synchronizedMap(Map map)
  Collection.synchronizedCollection(Collection c)
Q3) If an Employee class is present and its objects are added in an arrayList. Now I want the list to be sorted on the basis of the employeeID of Employee class. What are the steps?
Ans)
  • Implement Comparable interface for the Employee class and override the compareTo(Object obj) method in which compare the employeeID
  • Now call Collections.sort() method and pass the list as an argument.
Now consider that Employee class is a jar file.
  • 1) Since Comparable interface cannot be implemented, create Comparator and override the compare(Object obj, Object obj1) method .
  • 2) Call Collections.sort() on the list and pass comparator as an argument.
Q4)What is difference between HashMap and HashTable?
Ans) Both collections implements Map. Both collections store value as key-value pairs. The key differences between the two are
  1. Hashmap is not synchronized in nature but hashtable is.
  2. Another difference is that iterator in the HashMap is fail-safe while the enumerator for the Hashtable isn't. Fail-safe -if the Hashtable is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException?
  3. HashMap permits null values and only one null key, while Hashtable doesn't allow key or value as null.
Q5) What are the classes implementing List interface?
Ans) There are three implementation of List interface:
  1. ArrayList : It is a resizable array implementation. The size of the ArrayList can be increased dynamically also operations like add,remove and get can be formed once the object is created. It also ensures that the data is retrieved in the manner it was stored. The ArrayList is not thread-safe.
  2. Vector: It is thread-safe implementation of ArrayList. The methods are wrapped around a synchronized block.
  3. LinkedList: the LinkedList implements Queue interface too and provide FIFO (First In First Out) operation for add operation. It is faster than ArrayList if its mainly used forinsertion and deletion of elements.
Q6) Which all classes implement Set interface ?
Ans) A Set is a collection that contains no duplicate elements. More formally, a set contains no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element. HashSet,SortedSet and TreeSet are the commonly used class which implements Set interface.
  • SortedSet - It is an interface which extends Set. A the name suggest, the interface allows the data to be iterated in the ascending order or sorted on the basis of Comparator or Comparable interface. All elements inserted into the interface must implement Comparable or Comparator interface.
  • TreeSet - It is the implementation of SortedSet interface. This implementation provides guaranteed log(n) time cost for the basic operations (add, remove and contains). The class is not synchronized. The class uses Red-Black tree data structure.
  • HashSet: This class implements the Set interface, backed by a hash table (actually a HashMap instance). It makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time. This class permits the null element. This class offers constant time performance for the basic operations (add, remove, contains and size), assuming the hash function disperses the elements properly among the buckets
Q7) What is difference between List and a Set?
Ans)
  1. List can contain duplicate values but Set doesn't allow.
  2. List allows retrieval of data to be in same order in the way it is inserted but Set doesnt ensures the sequence in which data can be retrieved.(Except HashSet)
Q8) What is difference between Arrays and ArrayList ?
Ans)
  • Arrays are created of fix size whereas ArrayList is dynamic in nature and can vary its length. Also the size of array cannot be incremented or decremented. But with arrayList the size is variable.
  • Once the array is created elements cannot be added or deleted from it. But with ArrayList the elements can be added and deleted at runtime.
·         List list = new ArrayList();
·           list.add(1);
·           list.add(3);
  list.remove(0) //  will remove the element from the 1st location.
  • ArrayList is one dimensional but array can be multidimensional.
int[][][] intArray= new  int[3][2][1]; // 3 dimensional array
  • Array can contain objects of a single data type or class. ArrayList if not used with generic can contain objects of different classes
Q9) When to use ArrayList or LinkedList ?
Ans)
  1. Adding new elements is pretty fast for either type of list. Inserting element to nth location in arraylist and to first location in linkedlist takes O(1).
  2. For the ArrayList, doing random lookup using "get" is faster O(1), but for LinkedList O(n), it's slow. It's slow because there's no efficient way to index into the middle of a linked list. Linkedlist lookup always start from 1st location.
  3. When removing elements, using ArrayList is slow. This is because all remaining elements in the underlying array of Object instances must be shifted down for each remove operation. But LinkedList is fast, because deletion can be done simply by changing a couple of links.
So an ArrayList works best for cases where you're doing random access on the list and a LinkedList works better if you're doing a lot of editing in the middle of the list.
Source : Read More - from java.sun
Q11) What are advantages of iterating a collection using iterator?
Ans) For loop does not allow updating the colection(add or remove) whereas Iterator does. Also Iterator can be used where there is no clue what type of collections will be used because all collections implement Iterator interface.
Q12) Which design pattern Iterator follows?
Ans) It follows Iterator design pattern. Iterator Pattern is a type of behavioral pattern. The Iterator pattern is one, which allows you to navigate through a collection of data using a common interface without knowing about the underlying implementation. Iterator should be implemented as an interface. This allows the user to implement it anyway its easier for him/her to return data. The benefits of Iterator are about their strength to provide a common interface for iterating through collections without bothering about underlying implementation.
Example of Iteration design pattern - Enumeration The class java.util.Enumeration is an example of the Iterator pattern. It represents and abstract means of iterating over a collection of elements in some sequential order without the client having to know the representation of the collection being iterated over. It can be used to provide a uniform interface for traversing collections of all kinds.
Java Collections Interview Questions
Q) Why is it preferred to declare: List<String> list = new ArrayList<String>(); instead of ArrayList<String> = new ArrayList<String>();
Ans) It is preferred because:
  1. If later on code needs to be changed from ArrayList to Vector then only at the declaration place we can do that.
  2. The most important one – If a function is declared such that it takes list. E.g void showDetails(List list);
    When the parameter is declared as List to the function it can be called by passing any subclass of List like ArrayList,Vector,LinkedList making the function more flexible.
Q) What is ConcurrentHashMap ?
Ans) A concurrentHashMap is thread-safe implementation of Map interface. In this class put and remove method are synchronized but not get method. This class is different from Hashtable in terms of locking; it means that hashtable use object level lock but this class uses bucket level lock thus having better performance. The allowed concurrency among update operations is guided by the optional concurrencyLevel constructor argument (default 16), which is used as a hint for internal sizing. The table is internally partitioned to try to permit the indicated number of concurrent updates without contention. Because placement in hash tables is essentially random, the actual concurrency will vary. Ideally, you should choose a value to accommodate as many threads as will ever concurrently modify the table. Using a significantly higher value than you need can waste space and time, and a significantly lower value can lead to thread contention. But overestimates and underestimates within an order of magnitude do not usually have much noticeable impact. A value of one is appropriate when it is known that only one thread will modify and all others will only read. Also, resizing this or any other kind of hash table is a relatively slow operation, so, when possible, it is a good idea to provide estimates of expected table sizes in constructors.
Q) What is difference between iterator access and index access?
Ans) Index based access allow access of the element directly on the basis of index. The cursor of the datastructure can directly goto the 'n' location and get the element. It doesnot traverse through n-1 elements.
In Iterator based access, the cursor has to traverse through each element to get the desired element.So to reach the 'n'th element it need to traverse through n-1 elements.
Insertion,updation or deletion will be faster for iterator based access if the operations are performed on elements present in between the datastructure.
Insertion,updation or deletion will be faster for index based access if the operations are performed on elements present at last of the datastructure.
Traversal or search in index based datastructure is faster.
ArrayList is index access and LinkedList is iterator access.
Q) How to sort the list in reverse order?
Ans) To sort the elements of the List in the reverse natural order of the strings, get a reverse Comparator from the Collections class with reverseOrder(). Then, pass the reverse Comparator to the sort() method.
List list = new ArrayList();
Comparator comp = Collections.reverseOrder();
Collections.sort(list, comp)
Q) Can a null element be added to a Treeset or HashSet ?
Ans) A null element can be added only if the set is of size 1 because when a second element is added then as per set defination a check is made to check duplicate value and comparison with null element will throw NullPointerException.
HashSet is based on hashMap and can contain null element.
Q) How to sort list of strings - case insensitive ?
Ans) using Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
Q) How to make a List (ArrayList,Vector,LinkedList) read only ?
Ans) A list implemenation can be made read only usingCollections.unmodifiableList(list). This method returns a new list. If a user tries to perform add operation on the new list; UnSupportedOperationException is thrown.
Q) Which is faster to iterate LinkedHashSet or LinkedList?
Ans) LinkedList.
Q) Which data structure HashSet implements ?
Ans) HashSet implements hashmap internally to store the data. The data passed to hashset is stored as key in hashmap with null as value.
Q) Arrange in the order of speed - HashMap,HashTable, Collections.synchronizedMap,concurrentHashmap
Ans) HashMap is fastest, ConcurrentHashMap,Collections.synchronizedMap,HashTable.
Q23) What is identityHashMap?
Ans) The IdentityHashMap uses == for equality checking instead of equals(). This can be used for both performance reasons, if you know that two different elements will never be equals and for preventing spoofing, where an object tries to imitate another.
Q) What is WeakHashMap?
Ans) A hashtable-based Map implementation with weak keys. An entry in a WeakHashMap will automatically be removed when its key is no longer in ordinary use. More precisely, the presence of a mapping for a given key will not prevent the key from being discarded by the garbage collector, that is, made finalizable, finalized, and then reclaimed. When a key has been discarded its entry is effectively removed from the map, so this class behaves somewhat differently than other Map implementations.
Java Exception Interview Questions
Q1) What is an Exception?
Ans) The exception is said to be thrown whenever an exceptional event occurs in java which signals that something is not correct with the code written and may give unexpected result. An exceptional event is a occurrence of condition which alters the normal program flow. Exceptional handler is the code that does something about the exception.
Q2) Exceptions are defined in which java package?
Ans) All the exceptions are subclasses of java.lang.Exception
Q3) How are the exceptions handled in java?
Ans) When an exception occurs the execution of the program is transferred to an appropriate exception handler. The try-catch-finally block is used to handle the exception.
The code in which the exception may occur is enclosed in a try block, also called as a guarded region.
The catch clause matches a specific exception to a block of code which handles that exception.
And the clean up code which needs to be executed no matter the exception occurs or not is put inside the finally block
Q4) Explain the exception hierarchy in java.
Ans) The hierarchy is as follows:
Exception hierarchy in java
Throwable is a parent class of all Exception classes. There are two types of Exceptions:Checked exceptions and UncheckedExceptions or RunTimeExceptions. Both type of exceptions extends Exception class.
Q5) What is Runtime Exception or unchecked exception?
Ans) Runtime exceptions represent problems that are the result of a programming problem. Such problems include arithmetic exceptions, such as dividing by zero; pointer exceptions: such as trying to access an object through a null reference; and indexing exceptions: such as attempting to access an array element through an index that is too large or too small.
Runtime exceptions need not be explicitly caught in try catch block as it can occur anywhere in a program, and in a typical one they can be very numerous. Having to add runtime exceptions in every method declaration would reduce a program's clarity. Thus, the compiler does not require that you catch or specify runtime exceptions (although you can). The solution to rectify is to correct the programming logic where the exception has occurred or provide a check.
Q6) What is checked exception?
Ans) Checked exception are the exceptions which forces the programmer to catch them explicitly in try-catch block. It is a subClass of Exception. Example: IOException.
Q7) What is difference between Error and Exception?

Ans) An error is an irrecoverable condition occurring at runtime. Such as OutOfMemory error. These JVM errors you can not repair them at runtime.Though error can be caught in catch block but the execution of application will come to a halt and is not recoverable.
While exceptions are conditions that occur because of bad input or human error etc. e.g. FileNotFoundException will be thrown if the specified file does not exist. Or a NullPointerException will take place if you try using a null reference. In most of the cases it is possible to recover from an exception (probably by giving user a feedback for entering proper values etc.)
Q8) What is difference between ClassNotFoundException and NoClassDefFoundError?
Ans) A ClassNotFoundException is thrown when the reported class is not found by the ClassLoader in the CLASSPATH. It could also mean that the class in question is trying to be loaded from another class which was loaded in a parent classloader and hence the class from the child classloader is not visible.
Consider if NoClassDefFoundError occurs which is something like
java.lang.NoClassDefFoundError
src/com/TestClass
does not mean that the TestClass class is not in the CLASSPATH. It means that the class TestClass was found by the ClassLoader however when trying to load the class, it ran into an error reading the class definition. This typically happens when the class in question has static blocks or members which use a Class that's not found by the ClassLoader. So to find the culprit, view the source of the class in question (TestClass in this case) and look for code using static blocks or static members.
Q9) What is throw keyword?
Ans) Throw keyword is used to throw the exception manually. It is mainly used when the program fails to satisfy the given condition and it wants to warn the application.The exception thrown should be subclass of Throwable.
public void parent(){
    try{
      child();
    }catch(MyCustomException e){  }
  }
  public void child{
    String iAmMandatory=null;
    if(iAmMandatory == null){
      throw (new MyCustomException("Throwing exception using throw keyword");
    }
  }
Q10) What is use of throws keyword?
Ans) If the function is not capable of handling the exception then it can ask the calling method to handle it by simply putting the throws clause at the function declaration.
public void parent(){
 try{
    child();
  }catch(MyCustomException e){  }
 }
 public void child throws MyCustomException{
      //put some logic so that the exception occurs.
  }
Q11) What are the possible combination to write try, catch finally block?
Ans)
1 try{
  //lines of code that may throw an exception
}catch(Exception e){
  //lines of code to handle the exception thrown in try block
}finally{
  //the clean code which is executed always no matter the exception occurs or not.
}
2 try{}finally{}
3 try{
  }catch(Exception e){
    //lines of code to handle the exception thrown in try block
  }
The catch blocks must always follow the try block. If there are more than one catch blocks they all must follow each other without any block in between. The finally block must follow the catch block if one is present or if the catch block is absent the finally block must follow the try block.
Q12) How to create custom Exception?
Ans) To create you own exception extend the Exception class or any of its subclasses.
  • class New1Exception extends Exception { } // this will create Checked Exception
  • class NewException extends IOExcpetion { } // this will create Checked exception
  • class NewException extends NullPonterExcpetion { } // this will create UnChecked exception
Q13) When to make a custom checked Exception or custom unchecked Exception?
Ans) If an application can reasonably be expected to recover from an exception, make it a checked exception. If an application cannot do anything to recover from the exception, make it an unchecked exception.
Q14)What is StackOverflowError?
Ans) The StackOverFlowError is an Error Object thorwn by the Runtime System when it Encounters that your application/code has ran out of the memory. It may occur in case of recursive methods or a large amount of data is fetched from the server and stored in some object. This error is generated by JVM.
Q15) Why did the designers decide to force a method to specify all uncaught checked exceptions that can be thrown within its scope?
Ans) Any Exception that can be thrown by a method is part of the method's public programming interface. Those who call a method must know about the exceptions that a method can throw so that they can decide what to do about them. These exceptions are as much a part of that method's programming interface as its parameters and return value.

ava Exception Interview Questions

Q16) Once the control switches to the catch block does it return back to the try block to execute the balance code?
Ans) No. Once the control jumps to the catch block it never returns to the try block but it goes to finally block(if present).
Q17) Where is the clean up code like release of resources is put in try-catch-finally block and why?
Ans) The code is put in a finally block because irrespective of try or catch block execution the control will flow to finally block. Typically finally block contains release of connections, closing of result set etc.
Q18) Is it valid to have a try block without catch or finally?
Ans) NO. This will result in a compilation error. The try block must be followed by a catch or a finally block. It is acceptable to omit the either catch or the finally block but not both.
Q21) How do you get the descriptive information about the Exception occurred during the program execution?
Ans) All the exceptions inherit a method printStackTrace() from the Throwable class. This method prints the stack trace from where the exception occurred. It prints the most recently entered method first and continues down, printing the name of each method as it works its way down the call stack from the top.
Q23)Why is not considered as a good practice to write a single catch all handler to catch all the exceptions?
Ans) You can write a single catch block to handle all the exceptions thrown during the program.
If you use the Superclass Exception in the catch block then you will not get the valuable information about each of the exception thrown during the execution, though you can find out the class of the exception occurred. Also it will reduce the readability of the code as the programmer will not understand what is the exact reason for putting the try-catch block.
Q24) What is exception matching?
Ans) Exception matching is the process by which the the jvm finds out the matching catch block for the exception thrown from the list of catch blocks. When an exception is thrown, Java will try to find by looking at the available catch clauses in the top down manner. If it doesn't find one, it will search for a handler for a supertype of the exception. If it does not find a catch clause that matches a supertype for the exception, then the exception is propagated down the call stack. This process is called exception matching.
Q25) What happens if the handlers for the most specific exceptions is placed above the more general exceptions handler?
Ans) Compilation fails. The catch block for handling the most specific exceptions must always be placed above the catch block written to handle the more general exceptions.
//The code below will not compile.
try {            
    // code that can throw IOException or its subtypes             
} catch (IOException e) {
// handles IOExceptions and its subtypes
} catch (FileNotFoundException ex) { 
    // handle FileNotFoundException only
}
 
// The code below will compile successfully
try {
  // code that can throw IOException or its subtypes 
} catch (FileNotFoundException ex)  {
// handles IOExceptions and its subtypes
} catch (IOException e){
// handle FileNotFoundException only
}
Q26) Does the order of the catch blocks matter if the Exceptions caught by them are not subtype or supertype of each other?
Ans) No. If the exceptions are siblings in the Exception class’s hierarchy i.e. If one Exception class is not a subtype or supertype of the other, then the order in which their handlers(catch clauses) are placed does not matter.
Q27) What happens if a method does not throw an checked Exception directly but calls a method that does? What does 'Ducking' the exception mean?
Ans) If a method does not throw an checked Exception directly but calls a method that throws an exception then the calling method must handle the throw exception or declare the exception in its throws clause. If the calling method does not handle and declares the exception, the exceptions is passed to the next method in the method stack. This is called as ducking the exception down the method stack.
e.g. The code below will not compile as the getCar() method has not declared the CarNotFoundException which is thrown by the getColor () method.
void getCar() {
 getColor();
}
void getColor() {
 throw new CarNotFoundException();
}
//Fix for the above code is
void getCar() throws CarNotFoundException {
   getColor();
}
void getColor() {
  throw new CarNotFoundException();
}
Q28) Is an empty catch block legal?
Ans) Yes you can leave the catch block without writing any actual code to handle the exception caught
e.g. The code below is legal but not appropriate, as in this case you will nt get any information about the exception thrown.
Q29)Can a catch block throw the exception caught by itself?
Ans) Yes. This is called rethrowing of the exception by catch block.
e.g. the catch block below catches the FileNotFound exception and rethrows it again.
void checkEx() throws FileNotFoundException {
  try{
    //code that may throw the FileNotFoundException
 
  }catch(FileNotFound eFnf){
    throw FileNotFound();
  }
}


Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)