Some important java interview question for interviews and good to know concepts in Java. Best way to approach this article would be to first, try to answer the question yourself, then jump to solution.

Q1. What is the use of ‘volatile’ keyword in java?

Essentially, volatile keyword in java indicates that the variable will be modified by multiple threads, telling the compiler not to cache the value of that variable locally in each thread. All the reads/writes will directly go to main memory.

There is a performance downside of using volatile, since all the operations are being done on main memory.

Detail reading: http://tutorials.jenkov.com/java-concurrency/volatile.html

Q2. Why can’t java collections have primitive types?

It was a Java design decision, and one that some consider a mistake. Containers want Objects and primitives don’t derive from Object. In Java, it’s because of the way generics work. In Java, generics are a compile-time trick, that prevents you from putting an Image object into an ArrayList<String>. However, Java's generics are implemented with type erasure: the generic type information is lost during run-time. This was for compatibility reasons, because generics were added fairly late in Java's life. This means that, run-time, an ArrayList<String> is effectively an ArrayList<Object> (or better: just ArrayList that expects and returns Object in all of its methods) that automatically casts to String when you retrieve a value.

But since int doesn't derive from Object, you can't put it in an ArrayList that expects (at runtime) Object and you can't cast an Object to int either. This means that the primitive int must be wrapped into a type that does inherit from Object, like Integer.

For data structures like Map, which relies on hashcode() method of an object to find the key for that object will not be present in case of primitive types like int since they are don’t inherit from Object class.

Q3. How does the garbage collector work in Java?

Java has an attractive feature that enables developers to not explicitly manage the life cycle of objects. Objects are created when needed and automatically frees the objects when no longer in use. Garbage collections works in 3 simple steps:

1. Mark: Marks the memory spaces as eligible for gc, i.e. which objects are in use and which are not
2. Sweep: This step removes the objects marked in mark phase
3. Compaction: After sweep phase, the memory may become fragmented, it’s inefficient to keep track of these free spaces scattered around the memory, so at some point in time, this fragmented memory is compacted.

Q4. How is heap memory structured in Java?

All Garbage collectors in Java, split the heap memory into 2 parts called generations:

1. Old(Tenured) generation
2. Young generation (further divided into eden and survivor space)

There are many short lived objects created, let’s say during a loop, we store some intermediate data into an immutable object like String or BigDecimal.

It works as follows:

1. The objects are first allocated to young generation(eden space precisely) which is a small subset of entire heap.
2. When the young generation fills up, GC kicks in and stops all application threads and empty out the young generation. Objects that are no longer in use are discarded, and the objects still in use are moved to either survivor space or old generation, this is known as minor GC.
3. If an object stays long enough in survivor space, it’s moved to old gen.
4. Eventually, when old generation fills up, the JVM will need to find and clear the objects in it. This is where GC algorithms have big differences.

Q5. What are the different Garbage collection algorithms in Java?

There are 4 types of GC in Java.

1. Serial GC: Uses a single thread to process the heap, it’ll stop the application threads and compacts the old generation during this operation.
2. Throughput GC: Uses multiple threads, which makes the process much faster. It’s the default GC used. This also stops application threads during the process and can cause long pauses.
3. CMS GC: Application threads are stopped by CMS GC’s multiple threads to collect young generation. In case of old gen, instead of stopping the application threads in full GC, CMS uses one or more background thread to periodically scan old gen and discard unused objects. Young GC collection is also performed during this short duration only. Trade off here is high CPU usage. Also the background threads do not perform any compaction. It needs to be done separately when JVM is unable to allocate sufficient memory in heap.
4. G1 GC(used for large heaps > 4gb): This GC divides the heap into chunks, each chunk either belongs to old gen or young gen. Moving of live objects still happens using multiple threads and stopping application threads. The old gen is processed by background threads and moving the unused object from one segment to a designated segment enabling partial compaction. It is less likely for full gc to occur in this approach.

Q6. What is try-with-resource in java and how is it different from try-catch-finally?

try-with-resource is a exception handling mechanism that automatically closes the resources when you are done with them.

try(FileInputStream input = new FileInputStream("file.txt")) {
    int data = input.read();
    while(data != -1){
        System.out.print((char) data);
        data = input.read();
    }
}

It’s not just syntactic sugar, so where does it differ from try-catch-finally?

In case an exception occurs in try block, now try-with-resources will try to close the resource before propagating the exception, let’s say exception occurs while closing the resource too, here the first exception will be propagated up. This is opposite in case of try-catch-finally, in this case, the last exception that occurs will be propagated up.

Q7. Difference between Abstraction and Encapsulation?

1. Encapsulation is data hiding(information hiding) while Abstraction is detail hiding(implementation hiding).
2. While encapsulation groups together data and methods that act upon the data, data abstraction deals with exposing the interface to the user and hiding the details of implementation.