150+ Java Interview

Questions

Basic Intermediate
Advanced

tejasshah2k19@[Link]
 Basic Interview Questions

Q1. What are the data types in Java? Java has two types of
data types:

1. Primitive Data Types: These include byte, short, int, long, float,
double, char, and boolean. They store simple values and are not
objects.
2. Non-Primitive Data Types: These include String, Array, Class,
and Interface. They are derived from primitive data types and
provide more functionalities.

Q2. What are wrapper classes?

Wrapper classes provide an object representation of primitive data types,

such as Integers, Doubles, and Booleans. These classes allow primitives to
be used in collections and provide useful utility methods.

Q3. Are there dynamic arrays in Java?

Java arrays are fixed indynamically. Q4 size. However, ArrayList (from the
[Link] package) provides a dynamic array implementation where
elements can be added or removed dynamically.

Q4. What is JVM?

The Java Virtual Machine (JVM) is a part of the Java Runtime Environment
(JRE). It is responsible for executing Java bytecode by converting it into
machine code specific to the operating system.

Q5. Why is Java platform-independent?

Java achieves platform independence through bytecode. The Java

compiler converts code into bytecode, which the JVM interprets for the
underlying OS, making Java write-once, run-anywhere.

tejasshah2k19@[Link]
Q6. What are local and global variables?

● Local variables are declared inside methods or blocks and

are accessible only within their scope.
● Global variables (also called instance variables) are declared within
a class but outside any method and have a wider scope.

Q7. What is data encapsulation?

Encapsulation is an OOP principle where data (variables) and code

(methods) are bundled into a single unit (class). It restricts direct access to
data using access modifiers (private, protected).

Q8. What is function overloading?

Function overloading allows multiple methods to have the same name but
different parameter lists. The compiler differentiates them based on the
number or type of parameters.

Example:

public class Figure

{
public int area(int a, int b)
{
int rectangleArea = a*b;
return rectangleArea;
}
public int area(int a)
{
int squareArea = a*a;
return squareArea;
}
public static void main(String[] args )
{ Figure f = new Figure();
[Link]("Area of square " + [Link](5));
[Link]("Area of Rectangle " + [Link](5,3));
}
}

tejasshah2k19@[Link]
Q9. What is function overriding?

Overriding allows a subclass to provide a specific implementation of

a method defined in its superclass. It enables dynamic method
dispatch (runtime polymorphism).

Q10. Why is the main method static in Java?

The main method is static so that it can be called without creating an

instance of the class, allowing the program to start execution without object
instantiation.

Q11. What is the difference between the throw and throws

keywords in Java?

Feature throw throws

Purpose Used to explicitly Declares that a

throw an exception method may throw an
exception

Usage throw new public void

Exception("Error") myMethod() throws
IOException

Number of Can throw one Can declare

Exceptions exception at a time multiple exceptions
using commas

Q12. What do you mean by singleton class?

A singleton class ensures that only one instance of the class exists
throughout the application's lifecycle. It is implemented using a private
constructor, a static instance variable, and a public static method that
returns the single instance. The most common way to create a singleton
class is using the lazy initialization or eager initialization approach.

Q13. Does every try block need a catch block?

No, a try block does not necessarily need a catch block. It can be followed
by either a catch block, a final block, or both. A catch block handles
exceptions that may arise in the try block, while a final block ensures that
certain code

tejasshah2k19@[Link]
(such as resource cleanup) is executed regardless of whether an
exception occurs.

Q14. What is the usage of the super keyword in Java?

The super keyword in Java is used to refer to the parent class. It can be
used to:

1. Call the constructor of the parent class.

2. Access the parent class’s methods and variables when they
are overridden in a subclass.
3. Differentiate between methods and attributes of the parent and
child class when they have the same name.

Q15. What do you mean by the final keyword?

The final keyword is used to restrict modifications in Java. It can be

applied in three contexts:

1. Final variable: Its value cannot be changed once assigned.

2. Final method: Prevents method overriding in subclasses.
3. Final class: Prevents inheritance by other classes.

Q16. How is an exception handled in Java?

Java handles exceptions using the try-catch-finally mechanism:

1. Try block: Contains the code that might generate an exception.

2. Catch block: Handles the exception and defines what should be
done when an error occurs.
3. Finally block: Executes regardless of whether an exception occurs
or not, often used for resource cleanup (e.g., closing files or
database connections).

Q17. How can objects in a Java class be prevented from

serialization?

Serialization converts an object into a byte stream for storage or

transmission. To prevent serialization:

tejasshah2k19@[Link]
 1. Declare fields as transient to exclude them from serialization.
2. Implement writeObject() and readObject() methods to control
serialization.
3. Extend NotSerializableException to explicitly prevent serialization.

Q18. What is the difference between a constructor and a method in

Java?
Constructor Method
It has no return type. It always has a return type. It has a return
type void when not returning anything.
It always has the same name It can have any name of its choice.
as the class name.

Q19. Why is reflection used in Java?

Reflection in Java allows a running program to inspect and manipulate its
methods, fields, and constructors at runtime. It is commonly used in
frameworks, debugging tools, and JavaBeans to dynamically access class
properties.

Q20. What are the different types of ClassLoaders in Java?

Java provides three main types of ClassLoaders:

1. Bootstrap ClassLoader: Loads core Java classes from [Link] and

other essential libraries. It is implemented in native code and does
not have a Java class representation.
2. Extension ClassLoader: Loads classes from the JRE/lib/ext directory
or any other specified extension directories. It is implemented as
[Link]$ExtClassLoader.
3. System (Application) ClassLoader: Loads application classes from
the classpath (defined by CLASSPATH, -cp, or -classpath options). It
is a child of the Extension ClassLoader.

Q21. What is a copy constructor in Java?

A copy constructor creates a new object by copying the properties of an
existing object. It takes an instance of the same class as an argument and
initializes the new object with the same values.

tejasshah2k19@[Link]
Q22. What is object cloning in Java?

Object cloning is a way to create an exact copy of an object. Java provides

the clone() method from the Cloneable interface to perform shallow copies.
A shallow copy copies field values but does not duplicate referenced
objects, while a deep copy creates new instances of referenced objects.

Q23. Is Java a purely object-oriented language?

No, Java is not purely object-oriented because it supports primitive

data types like int, char, boolean, and double, which are not objects. A
purely object-oriented language would require every entity to be an
object.

Q24. What is a package in Java?

A package in Java is a collection of related classes and interfaces grouped to

organize code and prevent naming conflicts.

● Built-in packages: [Link], [Link], etc.

● User-defined packages: Created by developers for organizing
custom classes.

Q25. What is coercion in Java?

Coercion in Java refers to the automatic or explicit conversion of one data
type into another.

● Implicit coercion: Automatically converts smaller data types to

larger ones (e.g., int to double).
● Explicit coercion (casting): Converts larger data types to smaller
ones using type casting (e.g., (int) 3.14).

Q26. Can a private method be overridden in Java?

No, private methods cannot be overridden because they are not accessible
outside their class. If a subclass defines a method with the same name, it is

tejasshah2k19@[Link]
treated as a separate method rather than an override.

Q27. What are the phases in the lifecycle of a thread in Java?

A Java thread goes through the following states:

1. New: The thread is created but has not started executing.

2. Runnable: The thread is ready to run and waiting for CPU allocation.
3. Blocked: The thread is waiting for a resource or lock to be available.
4. Waiting: The thread is indefinitely waiting for another thread to
notify it.
5. Timed Waiting: The thread waits for a specified time (e.g.,
using [Link]()).
6. Terminated: The thread has completed execution or stopped due to
an error.

Q28. What is a marker interface in Java?

A marker interface is an interface with no methods or fields, used to provide

metadata to the JVM or compiler. Examples include Serializable and
Cloneable. Modern Java prefers annotations over marker interfaces.

Q29. What is a memory leak in Java?

A memory leak occurs when objects that are no longer needed are not
garbage collected because they are still referenced somewhere. This can
cause excessive memory consumption and slow down the application.

Q30. What is the difference between new and

newInstance() in Java?

● New is a keyword that creates a new object of a known class

at compile time.
● newInstance() (from Class) creates an object dynamically at
runtime, requiring reflection, and is slower because it involves
additional security and access checks.

tejasshah2k19@[Link]
Q31. What is the difference between JDK, JRE, and JVM?

● JDK (Java Development Kit) – Contains JRE + development tools

(compiler, debugger) for developing and running Java applications.
● JRE (Java Runtime Environment) – Includes JVM + libraries
needed to run Java applications but lacks development tools.
● JVM (Java Virtual Machine) – Executes Java bytecode, providing
platform independence and memory management (GC).

JDK > JRE > JVM – JDK includes JRE, and JRE includes JVM.
JDK is for developers, while JRE is for users running Java applications

Q32. What is the difference between abstraction and

encapsulation?

● Abstraction hides implementation details and exposes only

essential functionalities (e.g., using interfaces and abstract
classes).
● Encapsulation bundles data and methods within a class and
restricts direct access using access modifiers.

Q33. What is inheritance in Java?

Inheritance in Java is a mechanism where a child class acquires

properties and behaviors of a parent class, promoting code
reusability and hierarchical relationships.

● Achieved using the extends keyword.

● Supports single and multilevel inheritance (not multiple
inheritance with classes).
● Allows method overriding for polymorphism.
● The super (super) keyword is used to access parent class members.

Q34. What are functional interfaces in Java 8?

Functional interfaces have exactly one abstract method and are used with
lambda expressions.

tejasshah2k19@[Link]
Examples include Runnable, Callable, and Comparator.

Q35. What is polymorphism in Java?

Polymorphism allows the same method to behave differently based on the

context.

● Compile-time polymorphism (Method Overloading): Methods with

the same name but different parameters.
● Runtime polymorphism (Method Overriding): A subclass provides
a specific implementation of a parent method.

Q36. What is the purpose of the default keyword in interfaces?

The default keyword allows methods in interfaces to have default

implementations, enabling backward compatibility without forcing
all implementing classes to override them.

Q37. What is an interface in Java?

An interface in Java is a blueprint for classes that defines a contract

without implementation.

● Declared using the interface keyword.

● Contains only abstract methods (until Java 7).
● Java 8+ allows default and static methods with implementations.
● Supports multiple inheritance.
● Implemented by classes using the implements keyword.

Q38. What is the difference between ArrayList and Vector?

● ArrayList is not synchronized (faster), while Vector is

synchronized (thread-safe).
● ArrayList increases its size by 50% when full, while Vector doubles
its size.

tejasshah2k19@[Link]
Q39. What is an abstract class?

An abstract class in Java is a class that cannot be instantiated and

is meant to be extended by subclasses.

● Declared using the abstract keyword.

● Can have both abstract (without implementation) and
concrete methods.
● Used for partial implementation and code reusability.
● Must be extended by a subclass that provides
implementations for abstract methods.

Q40. What is the difference between HashMap and

ConcurrentHashMap?

● HashMap is not thread-safe, while ConcurrentHashMap is thread-safe.

● ConcurrentHashMap locks only portions of the map,
improving performance.
● HashMap allows one null key, but ConcurrentHashMap does not.

Q41. What is the difference between an abstract class and an

interface?

● Abstract class: Can have both abstract and concrete methods.

● Interface: Contains only abstract methods (before Java 8) and
supports multiple inheritance.

Q42. What is the Java Memory Model (JMM)?

The Java Memory Model (JMM) defines how threads interact with memory
and ensures visibility, ordering, and atomicity of shared data in a
multi-threaded environment.

● Controls how variables are read/written across threads.

● Ensures happens-before relationships to prevent race conditions.
● Uses volatile, synchronized, and locks for thread safety.

tejasshah2k19@[Link]
 ● Helps in optimizing CPU caching and instruction reordering.
● Ensures safe and predictable concurrency behavior.

Q43. What is this keyword in Java?

This refers to the current instance of a class, distinguishing between instance

variables and parameters with the same name.

Q44. What are Java Generics?

Generics provide compile-time type safety by allowing a class, method, or

interface to work with different types while avoiding runtime errors.

Q45. What are access modifiers in Java?

● Private: Accessible only within the same class.

● Default: Accessible within the same package.
● Protected: Accessible within the same package and subclasses.
● Public: Accessible from anywhere.

Q46. What is the purpose of the synchronized keyword?

Synchronized ensures that only one thread can execute a block of code
or method at a time, preventing race conditions.

Q47. What is a static method in Java?

A static method in Java belongs to the class, not instances. It can be

called using the class name without creating an object.

● Declared using the static keyword.

● Can access only static variables and methods directly.
● Cannot use this or super.
● Commonly used for utility methods (e.g., [Link]()).

class Example {
static void display() {

tejasshah2k19@[Link]
 [Link]("Static Method");
}
}
[Link](); // Call without creating an object
Q48. What are Java 8 Streams?

Java 8 Streams provides a functional programming approach to

processing data efficiently. They allow operations like filtering,
mapping, and reducing collections in a declarative and
parallelizable way.

● Supports sequential (stream()) and parallel

(parallelStream()) processing.
● Uses lazy evaluation for optimized execution.
● Common methods: filter(), map(), reduce(), collect(),
forEach().

Q49. What is garbage collection in Java?

1. Automatic Memory Management: Java's Garbage Collector

(GC) automatically reclaims memory by removing unused
objects.
2. Heap Memory Cleanup: GC works in the heap, where objects
are dynamically allocated.
3. Identifies Unreachable Objects: Objects with no active
references are eligible for garbage collection.
4. Prevents Memory Leaks: Helps manage memory efficiently
and avoids out-of-memory errors.
5. No Manual Deallocation: Unlike languages like C/C++, Java does
not require explicit free() or delete().
6. Uses Mark and Sweep Algorithm: Identifies live objects (mark) and
removes dead ones (sweep).
7. JVM Optimization for GC: JVM parameters like -Xms, -Xmx,
-XX:+UseG1GC help tune GC performance.

tejasshah2k19@[Link]
Q50. What is the difference between implements and extends?

● Implements are used for interfaces.

● Extends are used for class inheritance.

Intermediate Interview
Questions:
Q51. What is the purpose of the "assert" statement in Java?

The assert statement in Java is used to validate assumptions during

development and debugging. It checks whether a given expression
evaluates to true. If the condition is false, an AssertionError is thrown.

Assertions are mainly used for debugging and testing purposes to detect
logical errors early in the development process.

Q52. What is the difference between ArrayList and

LinkedList in Java?

● ArrayList: A resizable array-based data structure that provides fast

random access (O(1)) but slower insertions and deletions (O(n)) due
to shifting elements. It is preferred when frequent access operations
are needed.
● LinkedList: A doubly linked list implementation that allows
efficient insertions and deletions (O(1)) but slower random access
(O(n)). It is more suitable for scenarios with frequent modifications
and dynamic resizing.

Q53. What is the purpose of the hashCode() method in Java?

The hashCode() method generates a unique integer value (hash code) that
represents an object’s contents. It is primarily used in hash-based
collections like HashMap, HashSet, and Hashtable for efficient storage and
retrieval. A properly implemented hashCode() ensures better performance
in
hashing-based operations.

Q54. What is the purpose of the toString() method in Java?

tejasshah2k19@[Link]
The toString() method returns a string representation of an object, typically
including its class name and key attributes. It enhances debugging, logging,
and object readability. When an object is printed or concatenated with a
string, the toString() method is implicitly called. Developers often override it
to provide meaningful output.

Q55. How is encapsulation achieved in Java?

Encapsulation in Java is achieved using access modifiers (private, protected,

public) to restrict direct access to class members. It ensures data hiding
and maintains control over how data is accessed and modified. Getters
and setters are commonly used to enforce controlled access to private
variables.

Q56. What are method references in Java?

Method references provide a shorthand way to refer to existing methods

without executing them immediately. They improve code readability by
replacing lambda expressions with direct references to class or instance
methods. They are used with functional interfaces and written as
Class::methodName.

Example: [Link]::println instead of x -> [Link](x).

Q57. What are annotations in Java?

Annotations in Java are metadata tags used to provide additional

information about code elements such as classes, methods, and variables.

They start with @ (e.g., @Override, @Deprecated) and are used for
configuration, code documentation, validation, and runtime processing.
Annotations enhance code organization and facilitate frameworks like
Spring and Hibernate.

Q58. What is the BitSet class used for in Java?

The BitSet class represents a sequence of bits that can grow dynamically.
It provides efficient bitwise operations such as setting, clearing, flipping,
and checking bits. It is used for memory-efficient handling of binary data,
such as flags, filters, and permission settings.

Q59. What is a CyclicBarrier in Java?

tejasshah2k19@[Link]
A CyclicBarrier is a synchronization mechanism that allows multiple threads
to wait at a common barrier point until all threads reach it. Once all
participating threads arrive, they proceed together. It is useful in parallel
programming scenarios where tasks must be synchronized before
continuing execution.

Q60. What are the types of JDBC statements in Java?

JDBC (Java Database Connectivity) provides three types of statements for

database interaction:

● Statement: Executes simple SQL queries without parameters.

● PreparedStatement: Precompiled SQL statement with placeholders
for parameters, improving performance and security.
● CallableStatement: Used for executing stored procedures in
the database.

Q61. What is the Java String Pool?

The Java String Pool is a memory optimization technique where the JVM
stores string literals in a common pool to avoid redundant allocations.
When a new string literal is created, the JVM checks the pool first; if the
string exists, it reuses the reference instead of creating a new object. This
conserves memory and enhances performance.

Example:

tejasshah2k19@[Link]
String str1="Hello";
// "Hello" will be stored in String Pool
// str1 will be stored in stack memory

Q62. What is the difference between Path and Classpath?

1. Path specifies the location of system executables like Java and javac.

Classpath specifies the location of Java class files, JARs, and

resources.

2. Path is used by the operating system, while Classpath is used by the

JVM.
3. The path is set via the PATH environment variable, whereas
Classpath is set using CLASSPATH or -cp option.
4. Example: set PATH=C:\Java\bin (Path),
set CLASSPATH=C:\libs\[Link]
(Classpath).

Q63. What is the difference between Heap and Stack memory?

● Heap Memory: Stores objects and data that need to persist

throughout the program. Managed by the JVM’s garbage collector.
● Stack Memory: Holds method call frames and local variables. It
manages method execution and automatically deallocates
memory when a method exits.

Q64. Can we use String with a switch-case statement?

Yes, String can be used in a switch-case statement from Java 7

onwards. The switch works by computing the hashcode of the string
and then comparing it.

String fruit = "Apple";

switch (fruit) {
case "Apple": [Link]("It's an Apple!"); break; case
"Mango": [Link]("It's a Mango!"); break; default:
[Link]("Unknown fruit");

tejasshah2k19@[Link]
}

Key Points:

● Case labels are case-sensitive ("Apple" ≠ "apple").

● Uses [Link]() for comparison internally.
● Less efficient than integer-based switches due to hashing.

Q65. What are the different types of class loaders?

Java has three primary class loaders:

1. Bootstrap ClassLoader – Loads core Java classes (e.g., [Link]).

2. Extension ClassLoader – Loads classes from the JDK's
extensions directory ($JAVA_HOME/lib/ext).
3. System (Application) ClassLoader – Loads application classes from
the classpath, configurable using -cp or -classpath.

Q66. What is the difference between fail-fast and fail-safe

iterators?

● Fail-fast iterators: Immediately throw a

ConcurrentModificationException if a collection is modified
while iterating.
● Fail-safe iterators: Operate on a cloned copy of the collection,
allowing modifications without exceptions.

Q67. What is a compile-time constant in Java?

A compile-time constant is a value assigned at the time of compilation and

remains unchanged throughout execution. Example:

static final int MAX_VALUE = 100;

Q68. What is the difference between Map and Queue in Java?

● Map: Stores key-value pairs and allow fast retrieval based on keys
(e.g., HashMap).
● Queue: Stores elements in a specific order (FIFO, Priority-based, etc.),
designed for processing elements sequentially.

tejasshah2k19@[Link]
Q69. What is the difference between LinkedHashMap and
PriorityQueue?

● LinkedHashMap: Maintains insertion order and maps keys to values.

● PriorityQueue: Orders elements based on priority (natural ordering or
a custom comparator).

Q70. What is a memory-mapped buffer in Java?

A memory-mapped buffer allows a file to be directly mapped into memory,

improving I/O efficiency by enabling direct access to file contents. Useful for
handling large files.

Q71. What is the difference between notify() and notifyAll()?

● notify(): Wakes up one waiting thread.

● notifyAll(): Wakes up all waiting threads.

Q72. What are the types of exceptions in Java?

1. Checked Exceptions (e.g., IOException) – Must be handled

at compile-time.
2. Unchecked Exceptions (e.g., NullPointerException) – Occurs at
runtime and doesn't require explicit handling.

Q73. What is OutOfMemoryError?

● Error when JVM runs out of memory.

● Caused by memory leaks, large objects, or infinite loops.

Q74. What is the difference between == and equals()?

● == compares references (memory addresses).

● equals() compares object content (must be overridden in
custom classes).

Q75. How can you concatenate multiple strings in Java?

tejasshah2k19@[Link]
 1. + operator – Simple but creates new objects.
2. concat() – Works with String.
3. [Link]() – Efficient, recommended for
multiple concatenations.
4. [Link]() – Introduced in Java 8.

Q76. What are the main differences between Array and Collection?

● Array: Fixed size, stores elements of the same type.

● Collection: Dynamic size, can store elements of different types
(e.g., ArrayList, HashSet).

Q77. What is BlockingQueue in Java?

1. A thread-safe queue that blocks when empty/full.

2. Used in producer-consumer patterns.
3. Example: ArrayBlockingQueue, LinkedBlockingQueue.

Q78. What is the difference between a process and a thread?

● Process: Independent execution unit with its own memory space.

● Thread: Lightweight unit within a process, sharing memory with
other threads.

Q79. What are the advantages of multithreading?

● Efficient CPU utilization

● Faster task execution
● Improved application responsiveness
● Better handling of I/O operations

Q80. What is context switching?

1. The process of saving a thread’s state and switching to another.

2. Happens in multi-threading and multitasking.
3. Causes CPU overhead.

tejasshah2k19@[Link]
Q81. What is the difference between Array and ArrayList?

● Array: Fixed-size, stores primitive types and objects.

● ArrayList: Dynamic-size, stores only objects, provides built-in
resizing and utility methods.

Q82. What is the purpose of the volatile keyword?

1. Ensures visibility of shared variable updates across threads.

2. Prevents instruction reordering.
3. Used in multi-threading scenarios.

Q83. Explain Java NIO.

Java NIO (New I/O) provides faster I/O operations using:

● Channels & Buffers for data transfer

● Non-blocking I/O for asynchronous processing
● Selectors for managing multiple channels with a single thread

Q84. Difference between String, StringBuilder, and StringBuffer?

● String – Immutable, slower for modifications.

● StringBuilder – Mutable, fast, not thread-safe.
● StringBuffer – Mutable, thread-safe (synchronized).

Q85. Difference between Runnable and Callable?

● Runnable – No return value, cannot throw checked exceptions.

● Callable – Returns a value (Future<T>), and can throw
checked exceptions.

Q86. What is a checked exception in Java?

1. Exceptions checked at compile-time.

2. Must be handled using try-catch or throws.
3. Examples: IOException, SQLException.

tejasshah2k19@[Link]
Q87. Difference between static and final keywords?

● Static – Belongs to the class, shared across instances.

● Final – Makes variables constant, prevents method overriding &
class inheritance.

Q88. What is an unchecked exception?

1. Runtime exceptions that do not require handling (try-catch).

2. Examples: NullPointerException, ArrayIndexOutOfBoundsException.
3. Occurs due to programming errors.

Q89. Explain Java Lambda Expressions.

1. Introduced in Java 8 to enable functional programming.

2. Provides a concise way to write anonymous functions.
3. Used with functional interfaces (Runnable, Comparator).

Example:
(a, b) -> a + b

Q90. Purpose of the try-catch block?

1. Handles runtime exceptions to prevent program crashes.

2. Try contains risky code, and catch handles exceptions.
3. Ensures graceful error handling.

Example:

try { int x = 10 / 0; } catch (ArithmeticException e) { [Link]("Error!");

}

Q91. Difference between Collection and Collections?

● Collection: Interface representing data structures (e.g., List, Set).

● Collections: A utility class for collection operations (e.g.,
sorting, searching).

tejasshah2k19@[Link]
Q92. Use of the finalize() method?

1. Called by a Garbage Collector before an object is reclaimed.

2. Used for cleanup operations (e.g., closing files, releasing resources).
3. Deprecated in Java 9 due to unpredictable behavior.

Q93. Explain Java 8 Optional.

1. A container object for handling null values safely.

2. Helps avoid NullPointerException.
3. Methods: of(), ofNullable(), isPresent(), orElse(), map().

Q94. What is the Java Collection Framework?

1. A set of classes & interfaces for managing groups of objects.

2. Includes List (ArrayList), Set (HashSet), Map (HashMap),
Queue (PriorityQueue), etc.
3. Provides efficient data structures & algorithms for
handling collections.

Q95. Explain Java 8 CompletableFuture.

1. A non-blocking way to handle asynchronous programming.

2. Supports callbacks (thenApply(), thenAccept()) and
chaining multiple tasks.
3. Uses the ForkJoinPool for efficient execution.

Q96. What is multithreading in Java?

1. Allows parallel execution of multiple tasks (threads).

2. Improves CPU utilization & performance.
3. Created using Thread class or Runnable interface.
4. Managed using Executors, Fork/Join, and CompletableFuture.

Q97. Purpose of the strictfp keyword?

1. Ensures consistent floating-point calculations across platforms.

tejasshah2k19@[Link]
 2. Enforces IEEE 754 standard for precision.
3. Used with classes & methods but not variables.

Q98. Difference between sleep() and wait()?

● sleep(): Pauses thread but retains lock.

● wait(): Releases lock and waits for notify().

Q99. Difference between LinkedHashSet and TreeSet?

● LinkedHashSet maintains insertion order, while TreeSet maintains

sorted order (natural or custom comparator).
● LinkedHashSet uses a HashMap with a linked list, whereas
TreeSet is based on a Red-Black Tree.
● LinkedHashSet has O(1) time complexity for add, remove,
and contains, while TreeSet has O(log n) due to tree
balancing.
● LinkedHashSet allows null elements, but TreeSet does not allow null
(throws NullPointerException).
● LinkedHashSet is best for maintaining insertion order with fast
lookups, while TreeSet is ideal for sorting unique elements and
range queries.

Q100. What is synchronization in Java?

Synchronization in Java is a mechanism that ensures thread safety by

controlling access to shared resources in a multi-threaded
environment. It prevents race conditions and ensures data
consistency when multiple threads access a shared object. Java provides
synchronization through the synchronized keyword, which can be
applied at the method or block level to allow only one thread to execute a
critical section at a time.

Additionally, explicit locks (ReentrantLock), volatile variables, and

atomic classes (AtomicInteger, ConcurrentHashMap) offer
alternative ways to handle concurrency efficiently. While synchronization
ensures safe execution, excessive use can lead to performance
overhead due to thread blocking

tejasshah2k19@[Link]
and context switching.

Advanced Interview Questions:

Q101. How does the JVM handle method overloading and

overriding internally?

Method overloading is resolved at compile-time, where the compiler

determines the method signature based on argument types. Method
overriding, on the other hand, is resolved at runtime using dynamic
method dispatch, where the JVM decides which method to invoke based
on the actual object type.

Q102. Explain Java's Non-blocking Algorithms and how they

differ from traditional blocking algorithms.

Non-blocking algorithms allow multiple threads to operate on shared data

without using locks, improving performance and avoiding issues like
deadlocks. In contrast, traditional blocking algorithms use locks to
synchronize access, potentially leading to contention and reduced
concurrency.

Q103. How can you create an immutable class in Java?

To create an immutable class:

● Declare the class as final.

● Make all fields private and final.
● Do not provide setters.
● Ensure deep copies of mutable fields in constructors and getters.
● Avoid exposing mutable references.

tejasshah2k19@[Link]
Q104. Describe the Contract of hashCode() and equals() methods.

● If two objects are equal according to equals(), they must have

the same hashCode().
● However, two objects with the same hashCode() may not
necessarily be equal.
● Properly overriding both methods ensures correct behavior
in hash-based collections like HashMap and HashSet.

Q105. What is Type Inference in Generics?

Inner Workings of ConcurrentHashMap

ConcurrentHashMap in Java is a thread-safe, high-performance

alternative to HashMap, optimized for concurrent access.

How It Works:

1. Segmented Locking (Java 7 and earlier) – The map was divided into
segments, reducing lock contention.
2. CAS (Compare-And-Swap) & Fine-Grained Locking (Java 8+) –
Instead of segments, it uses locks at bucket level and CAS
operations for updates.
3. Bucket-Level Synchronization – Write operations lock
only the affected bucket, allowing parallel updates.
4. No Lock for Reads – Most read operations (get()) are lock-
free, ensuring high performance.
5. Improved Scalability – Reduces contention, making it efficient
for multi-threaded environments.

Key Benefits:

✅ Faster than [Link]() due to reduced locking.

✅ Supports high-concurrency scenarios like caching and real-time
analytics.
✅ Atomic operations (putIfAbsent(), compute(), etc.) ensure thread
safety.

Q106. Explain the inner workings of ConcurrentHashMap.

tejasshah2k19@[Link]
Inner Workings of ConcurrentHashMap:ConcurrentHashMap in Java
is a thread-safe, high-performance alternative to HashMap, optimized
for concurrent access.

How It Works:

6. Segmented Locking (Java 7 and earlier) – The map was divided into
segments, reducing lock contention.
7. CAS (Compare-And-Swap) & Fine-Grained Locking (Java 8+) –
Instead of segments, it uses locks at bucket level and CAS
operations for updates.
8. Bucket-Level Synchronization – Write operations lock
only the affected bucket, allowing parallel updates.
9. No Lock for Reads – Most read operations (get()) are lock-
free, ensuring high performance.
10. Improved Scalability – Reduces contention, making it
efficient for multi-threaded environments.

Key Benefits:

✅ Faster than [Link]() due to reduced locking.

✅ Supports high-concurrency scenarios like caching and real-time
analytics.
✅ Atomic operations (putIfAbsent(), compute(), etc.) ensure thread
safety.

Q107. Describe the Java Memory Fence and its

importance. Java Memory Fence & Its Importance

A Memory Fence (or Memory Barrier) in Java ensures proper ordering of

memory operations in a multi-threaded environment, preventing
reordering by the CPU or compiler.

How It Works:

1. Prevents Instruction Reordering – Ensures operations happen

in the expected sequence.
2. Ensures Visibility Across Threads – Changes made by one
thread become visible to others.
3. Used in Concurrency Primitives – Found in volatile,
synchronized, and Lock implementations.

tejasshah2k19@[Link]
Why It's Important?

✅ Prevents data races & inconsistencies in multi-threaded applications.

✅ Ensures correct execution order in concurrent programming.
✅ Optimizes performance while maintaining thread safety.

Q108. Explain the concept of False Sharing in Java.

False sharing occurs when multiple threads modify variables that reside
in the same CPU cache line, causing unnecessary cache invalidations
and performance degradation.

Q109. How do you handle OutOfMemoryError in Java?

To handle OutOfMemoryError:

● Optimize memory usage and avoid memory leaks.

● Increase heap size using JVM options (-Xmx).
● Use efficient data structures.
● Employ garbage collection tuning strategies.
● Implement graceful degradation mechanisms.

Q110. Describe Escape Analysis in Java optimizations.

Escape analysis is a compiler optimization technique that

determines whether an object can be allocated on the stack
instead of the heap, reducing memory allocation overhead and
improving performance.

Q111. Explain Thread Starvation and how to prevent it.

Thread starvation occurs when low-priority threads are indefinitely delayed

due to high-priority threads monopolizing CPU time.

It can be prevented by:

● Using fair locks (ReentrantLock with fairness parameter).

● Adjusting thread priorities carefully.
● Ensuring resource allocation is balanced.

Q112. How does Class Data Sharing (CDS) work in JVM?

tejasshah2k19@[Link]
Class Data Sharing (CDS) is a JVM optimization technique that reduces
startup time and memory usage by preloading and sharing class metadata
across JVM instances.

How It Works:

1. CDS Archive Creation – During JVM execution, class metadata

is stored in a shared archive file.
2. Faster Startup – On subsequent runs, JVM loads classes from
the precompiled archive, avoiding costly parsing.
3. Memory Efficiency – Multiple JVM instances share the same
metadata, reducing RAM usage.

Q113. Explain Java’s Thread-Local Allocation Buffers (TLAB).

Java’s Thread-Local Allocation Buffers (TLAB)

Thread-Local Allocation Buffers (TLAB) is a JVM optimization that improves

object allocation speed by providing each thread a private memory buffer
in the Young Generation heap.

How It Works:

1. Each thread gets a small, preallocated space in the Eden space.

2. Fast object allocation occurs within this space,
avoiding synchronization.
3. When TLAB is full, objects spill over to the shared heap, triggering
GC if needed.

Benefits:

✅ Faster Object Allocation – No locking required, reducing contention.

✅ Improved GC Performance – Most objects remain in Eden, reducing Old
Gen promotion.
✅ Better Multi-Threading Efficiency – Each thread allocates independently.

Q114. How does the Fork/Join Framework work?

The Fork/Join Framework (introduced in Java 7) is designed for parallel

execution of tasks using a divide-and-conquer approach.

tejasshah2k19@[Link]
How It Works:

1. Task Splitting (fork()) – A task is split into smaller subtasks

recursively.
2. Parallel Execution – The subtasks run in a ForkJoinPool,
utilizing multiple CPU cores.
3. Task Joining (join()) – The results of subtasks are combined
once the computation is complete.
4. Work Stealing – Idle threads steal tasks from busy threads,
improving efficiency.

Q115. What is the difference between Pessimistic Locking

and Optimistic Locking?

● Pessimistic Locking: Locks resources throughout the transaction,

preventing concurrent modifications.
● Optimistic Locking: Allows concurrent access but verifies
data consistency before committing changes, reducing
contention.

Q116. Explain the inner workings of a Java Agent.

Java Agents use the [Link] package to modify bytecode at

runtime or load-time for profiling, monitoring, or altering application
behavior dynamically.

Q117. Describe the uses of Java Compiler

API. Uses of Java Compiler API

The Java Compiler API ([Link]) allows

programmatic compilation of Java code within applications.

Key Uses:

1. Dynamic Code Compilation – Compile Java code at runtime

(e.g., scripting engines).
2. Custom IDEs & Tools – Used in IDEs for syntax checking
and on-the-fly compilation.
3. Code Generation Frameworks – Supports frameworks like
annotation processors.

tejasshah2k19@[Link]
 4. Plugin Systems – Enables plugins to compile and execute custom
Java code.
5. Testing & Automation – Helps run dynamically generated test cases.

Q118. What is the Principle of Locality, and how does it

apply to Java?

The Principle of Locality states that programs tend to reuse the same set of
memory locations frequently. Java optimizes cache utilization by keeping
frequently accessed data close to the CPU.

Q119. How does the G1 Garbage Collector work?

G1 GC divides the heap into regions and prioritizes collecting regions with
the most garbage, improving performance and reducing pause times.

Q120. Explain Polymorphic Inline Caching (PIC).

Polymorphic Inline Caching (PIC) in Java

Polymorphic Inline Caching (PIC) is a JIT optimization technique that speeds

up method dispatch in dynamically-typed and polymorphic code.

How Does It Work?

1. Caches multiple method targets instead of looking them up every time.

2. Reduces virtual method call overhead by optimizing frequently
called methods.
3. Improves performance in polymorphic scenarios where
multiple subclasses override a method.

Impact on Performance:

✅ Faster method dispatch than standard virtual calls.

✅ Reduces CPU cache misses by keeping method lookups efficient.
✅ Common in JVM JIT compilers like HotSpot.

tejasshah2k19@[Link]
Q121. What is the difference between StampedLock and
ReentrantLock?

Difference Between StampedLock and ReentrantLock

1. Locking Mechanism
○ StampedLock: Provides optimistic and pessimistic
locking, improving read performance.
○ ReentrantLock: Traditional exclusive locking, allowing
multiple reentrant acquisitions by the same thread.
2. Read Performance
○ StampedLock: Supports optimistic reads without
blocking, making it faster.
○ ReentrantLock: This does not support optimistic reads,
and always requires acquiring a lock.
3. Write Locking
○ StampedLock: Provides an exclusive write lock,
invalidating optimistic read stamps.
○ ReentrantLock: Standard exclusive lock with thread reentrancy.
4. Interruptibility
○ StampedLock: Write locks are not interruptible, making
them less flexible in some cases.
○ ReentrantLock: Supports interruptible locking, useful
for responsiveness.
5. Use Case
○ StampedLock: Best for high-read, low-write scenarios
(e.g., caches, data structures).
○ ReentrantLock: Suitable for general-purpose locking
where fairness and reentrancy are needed.

Q122. Explain the term "Busy Spin" in multi-

threading. Busy Spin in Multi-Threading

tejasshah2k19@[Link]
 Busy Spin is a technique where a thread continuously loops (spins)
while waiting for a condition to be met, instead of sleeping or blocking.
It helps reduce context switching overhead but wastes CPU cycles.

Example:
while (!conditionMet) {
// Busy-wait (spinning)
}

When to Use?

✅ Low-latency systems (e.g., high-frequency trading) where thread wake-up

delays are costly.
✅ Short wait times where context switching overhead is higher than
spinning cost.

Drawbacks:

❌ High CPU usage – Can degrade system performance.

❌ Inefficient for long waits – Better to use [Link]() or blocking
mechanisms.

Q123. How can you implement a custom ClassLoader?

Create a subclass of ClassLoader and override methods like findClass(),

loadClass(), and defineClass() to customize class loading behavior.

Q124. Describe Java JIT Compiler optimizations like Loop

Unrolling and Vectorization.

The Java Just-In-Time (JIT) Compiler applies various optimizations to

improve runtime performance:

● Loop Unrolling: Reduces the overhead of loop control (e.g.,

incrementing indices, checking conditions) by increasing the number
of operations in the loop body, and reducing the number of
iterations.
● Vectorization: Converts scalar operations into vector operations,
allowing multiple data elements to be processed simultaneously
using SIMD (Single Instruction, Multiple Data) instructions,
significantly improving performance on modern CPUs.

tejasshah2k19@[Link]
Q125. Explain the use of the jstack tool.

jstack is a Java utility that displays the stack traces of Java threads in a
running JVM. It is useful for debugging, diagnosing deadlocks, and
analyzing performance bottlenecks.

Q126. Describe Java's Project Loom and its impact on

concurrency. Java's Project Loom & Its Impact on

Concurrency

Project Loom (introduced in Java 21) enhances concurrency by introducing

virtual threads, which are lightweight, user-mode threads managed by
the JVM.

Impact on Concurrency:

1. Massive Scalability – Supports millions of virtual threads vs. limited

OS threads.
2. Simplifies Concurrency – Replaces complex ThreadPool
management with lightweight threading.
3. Efficient Resource Utilization – Uses fewer system resources,
reducing context switching overhead.
4. Better Performance for I/O Tasks – Ideal for high-
throughput, I/O-bound applications like web servers.
5. Easy Migration – Works seamlessly with existing Java threading APIs.

Q127. What is a Java Decompiler, and how can it be used

securely? Java Decompiler & Secure Usage

A Java Decompiler converts compiled .class files back into readable

Java source code, helping in debugging, reverse engineering, and
learning from third-party libraries.

Secure Usage of Java Decompilers:

tejasshah2k19@[Link]
 1. Avoid Decompiling Proprietary Code – Respect copyright and
licensing laws.
2. Use for Debugging & Recovery – Retrieve lost source code
from compiled classes.
3. Analyze Security Risks – Identify vulnerabilities in
compiled applications.
4. Prevent Reverse Engineering – Use obfuscation tools
(e.g., ProGuard) to protect code.
5. Trusted Decompilers – Use reliable tools like JD-GUI, CFR, or
Fernflower to avoid malware risks.

Q128. What are the challenges in implementing

Distributed Garbage Collection (DGC)?

DGC is complex because it must manage memory across multiple JVMs.

Challenges include:

● Tracking object references across distributed systems

● Handling network latency and failures
● Avoiding memory leaks and orphaned objects
● Minimizing performance overhead

Q129. Describe the impact of JVM flags on performance tuning.

Impact of JVM Flags on Performance Tuning

JVM flags optimize memory, garbage collection (GC), and execution

speed, directly affecting application performance.

1. Heap Size Management

○ -Xms<size> & -Xmx<size>: Control initial & max heap
size, preventing excessive GC.
2. Garbage Collection (GC) Optimization
○ -XX:+UseG1GC, -XX:+UseZGC: Tune GC for low-latency or
high-throughput apps.
3. JIT Compilation
○ -XX:+TieredCompilation: Speeds up execution by
optimizing method compilation.
4. Thread & CPU Usage

tejasshah2k19@[Link]
 ○ -XX:ActiveProcessorCount=<N>: Controls CPU usage for
better multi-threading.
5. Logging & Debugging
○ -XX:+PrintGCDetails: Monitors GC activity, aiding
performance tuning.

Q130. What are Java Modules, and how do they enhance

security and maintainability?

Java Modules (Introduced in Java 9)

Java Modules ([Link]) help organize code into self-contained,

reusable units, improving security, maintainability, and performance.

How Modules Enhance Security & Maintainability?

1. Encapsulation & Restricted Access

○ Unlike traditional public classes, only explicitly
exported packages are accessible, preventing
unintended usage.
2. Explicit Dependencies
○ require keywords to ensure a module only uses
necessary dependencies, avoiding classpath
conflicts.
3. Improved Maintainability
○ Large applications can be split into small,
independent modules, making it easier to
manage and scale.
4. Reduced Attack Surface
○ Since internal classes are not exposed by default,
security vulnerabilities due to unintended access are
minimized.
5. Faster Startup & Performance
○ JVM loads only required modules, improving startup time
and reducing memory usage.

Q131. Explain the concept of Java 8

parallelStream(). Java 8 parallelStream() Concept

The parallelStream() method in Java 8 allows parallel processing

of collections using the ForkJoin framework, improving
performance on multi-core processors.
tejasshah2k19@[Link]
Key Features:

1. Splits data into multiple sub-tasks and processes them in parallel.

2. Uses ForkJoinPool internally for task execution.
3. Ideal for large data sets where parallelism improves efficiency.
4. Order of execution is not guaranteed, unlike stream()

When to Use parallelStream()?

✅ CPU-intensive tasks (e.g., large computations, data processing).

✅ Processing large collections for better performance.
✅ Multi-core processors where parallel execution speeds up work.

When to Avoid?

❌ Small datasets (overhead may reduce performance).

❌ Dependent tasks (race conditions can occur).
❌ Modifying shared resources (risk of inconsistent state).

Q132. What is a deadlock in Java?

A deadlock occurs when two or more threads are indefinitely blocked, each
waiting for a resource held by another.

Example:

● Thread A locks Resource 1 and waits for Resource 2

● Thread B locks Resource 2 and waits for Resource 1
Proper synchronization strategies, such as lock ordering or timeouts,
help prevent deadlocks.

Q133. What is the difference between Executor and

ExecutorService?

Difference Between Executor and ExecutorService in Java

1. Definition
○ Executor: A simple interface for executing tasks asynchronously.
○ ExecutorService: A more advanced interface that extends
Executor and provides additional control over thread
execution.
2. Functionality

tejasshah2k19@[Link]
 ○ Executor: Only has one method: execute(Runnable
command), which runs a task asynchronously.
○ ExecutorService: Supports more methods like
submit(), invokeAll(), shutdown(), and
awaitTermination().
3. Task Handling
○ Executor: Just fires and forgets tasks without managing
their completion.
○ ExecutorService: Returns Future<T> objects, allowing
task tracking and results retrieval.
4. Shutdown Control
○ Executor: Does not provide shutdown control.
○ ExecutorService: Provides methods like shutdown(),
and shutdownNow() to gracefully stop tasks.

Q134. What is the difference between HashMap and Hashtable?

Feature HashMap Hashtable

Synchronization Not synchronized(not Synchronized(thread-safe)

thread-safe)

Null keys/values Allows one null key and Does not allow null keys or
multiple null values. values.

Performance Faster Slower due to

synchronization

Q135. Explain Java 8 default methods in interfaces.

Java 8 introduced default methods in interfaces using the default keyword,

allowing interfaces to have concrete method implementations without
breaking existing classes.

Key Features:

1. Provides method implementation inside interfaces using default.

2. Maintains backward compatibility without forcing all
implementing classes to override.
3. Supports multiple inheritance of behavior, but avoids
diamond problem with explicit method resolution.

tejasshah2k19@[Link]
Q136. What is the difference between wait() and notify()?

Difference Between wait() and notify() in Java

1. Purpose
○ wait(): Causes the current thread to release the lock and
enter a waiting state.
○ notify(): Wakes up one waiting thread from the waiting state.
2. Usage
○ wait(): Called when a thread needs to wait for a condition.
○ notify(): Called when a thread wants to signal a waiting
thread to resume execution.
3. Lock Requirement
○ Both wait() and notify() must be called inside a
synchronized block on the same object monitor.
4. Thread Behavior
○ wait(): The thread releases the lock and goes to the
waiting queue.
○ notify(): The awakened thread must reacquire the lock
before proceeding.

Q137. What is the difference between Comparable and

Comparator?

Comparable vs. Comparator in Java

1. Purpose
○ Comparable: Used for natural ordering of objects (e.g., sorting
by ID).
○ Comparator: Used for custom ordering (e.g., sorting by name,
age, etc.).
2. Implementation
○ Comparable: Implemented by the class itself
(implements Comparable<T>).

tejasshah2k19@[Link]
 ○ Comparator: Implemented as a separate class (implements
Comparator<T>).
3. Method Used
○ Comparable: Overrides compareTo(T o).
○ Comparator: Overrides compare(T o1, T o2).
4. Usage
○ Comparable: Used when a single sorting order is needed.
○ Comparator: Used when multiple sorting criteria are required.

Q138. What is the transient keyword in Java?

Transient prevents a field from being serialized, meaning it will not be saved
when an object is written to a file or transmitted over a network.

Q139. What is the purpose of the instanceof operator?

instanceof checks if an object is an instance of a specific class or

subclass. Example:

if (object instanceof MyClass) {

// Do something

Q140. Explain the concept of lock-free programming in Java.

Lock-free programming in Java ensures thread-safe concurrency without

using traditional locks (synchronized, ReentrantLock). Instead, it relies on
atomic operations and Compare-And-Swap (CAS) to manage shared
resources efficiently.

How It Works:

1. Uses Atomic Classes – Java provides AtomicInteger,

AtomicLong, AtomicReference, etc., from
[Link].
2. Relies on CAS (Compare-And-Swap) – Instead of locking,
CAS updates a value only if it hasn't changed, ensuring
consistency.
3. Avoids Blocking & Deadlocks – Threads keep retrying operations
until they succeed, improving performance.

tejasshah2k19@[Link]
 4. Optimized by Hardware – CAS operations leverage CPU-
level instructions for fast, low-overhead execution.
5. Used in Concurrent Data Structures – ConcurrentHashMap,
ConcurrentLinkedQueue, and AtomicStampedReference use lock-
free techniques.

Q141. What is [Link]fl[Link] used for?

Proxy dynamically creates objects implementing interfaces at runtime. It is

widely used in AOP (Aspect-Oriented Programming) and frameworks like
Spring.

Q142. What are some advanced features of

CompletableFuture in Java?

● Chaining asynchronous tasks

● Combining multiple async computations
● Exception handling
● Timeouts and default values
● Custom executor control

Q143. What is ForkJoinPool, and how is it different from a

regular thread pool?

ForkJoinPool (introduced in Java 7) is a specialized thread pool designed

for parallel processing of recursive tasks using the work-stealing algorithm.
It is part of the [Link] package.

ForkJoinPool vs. Regular Thread Pool

1. Task Type
○ ForkJoinPool: Designed for divide-and-conquer tasks
(RecursiveTask, RecursiveAction).
○ Regular Thread Pool: Executes independent
Runnable/Callable tasks.
2. Work Stealing

tejasshah2k19@[Link]
 ○ ForkJoinPool: Uses work-stealing (idle threads take tasks
from busy threads).
○ Regular Thread Pool: No work-stealing; tasks are assigned
to specific threads.
3. Best Use Case
○ ForkJoinPool: Ideal for CPU-intensive, recursive parallel
processing (e.g., sorting, tree traversal).
○ Regular Thread Pool: Suitable for I/O tasks, web servers,
and background tasks.
4. Task Splitting & Execution
○ ForkJoinPool: Splits large tasks into subtasks (fork() & join()).
○ Regular Thread Pool: No built-in task splitting, executes
tasks independently.
5. Performance Optimization
○ ForkJoinPool: Optimized for parallel execution using all available
CPU cores.
○ Regular Thread Pool: Works well for asynchronous task
execution but lacks parallel optimization.

Q144. How does the Unsafe class work, and what are its use
cases?

Unsafe Class in Java ([Link])

The Unsafe class provides low-level, unsafe operations such as direct

memory access, off-heap allocation, and atomic operations. It bypasses
standard Java safety checks, making it powerful but dangerous.

Key Features:

● Memory manipulation (allocateMemory(), freeMemory(), putInt(), etc.).

● Bypass constructor calls (allocateInstance() to create objects
without calling a constructor).
● CAS (Compare-And-Swap) operations for atomic variables (used
in [Link]).
● Thread operations (park(), unpark(), getAndSetInt(), etc.).
● Class loading manipulation (defineClass(), defineAnonymousClass()).

Use Cases:

● High-performance libraries (e.g., Netty, Cassandra).

● Off-heap memory storage (avoids GC overhead).

tejasshah2k19@[Link]
 ● Atomic operations (used in AtomicInteger, ConcurrentHashMap).
● Class and method hacking (modifying final fields, method handles).

Q145. What is PhantomReference in Java?

PhantomReference in Java

PhantomReference (from [Link]) is a special type of reference that

allows post-mortem cleanup after an object is garbage collected. Unlike
SoftReference and WeakReference, a PhantomReference is always null
when accessed via get().

Key Features:

● Used for resource cleanup (e.g., deallocating native memory).

● Not automatically removed by GC; it is added to a
ReferenceQueue instead.
● Ensures proper cleanup before memory is reclaimed.

Q146. Explain the concept of MethodHandle in Java.

MethodHandle in Java

MethodHandle (introduced in Java 7, [Link]) is a lightweight, faster

alternative to reflection for dynamically invoking methods, constructors, and
fields. It offers better performance and type safety compared to
[Link]fl[Link].

Key Points:

● More efficient than reflection (Method).

● Supports dynamic invocation of private, public, static, and
instance methods.
● Type-safe (checked at compile time).
● Used internally in lambdas & invokedynamic for
JVM optimizations.

When to Use?

● When better performance than reflection is needed.

● For dynamic method invocation (e.g., lambda metafactories).

tejasshah2k19@[Link]
 ● In JVM internals and advanced frameworks.

Q147. What is the role of [Link]?

The [Link] package enables bytecode modification at

runtime, used in Java agents for profiling, monitoring, and aspect-oriented
programming.

Q148. How does the Java Memory Model handle out-of-order

execution and memory visibility?

● Defines happens-before relationships for correct memory visibility

● Uses volatile and synchronized to enforce ordering
● Prevents compiler and CPU optimizations that may break
concurrency semantics

Q149. What is the difference between ReentrantLock and

synchronized?

1. Synchronized is a built-in Java monitor lock, while ReentrantLock

is part of [Link] with more flexibility.
2. Synchronized acquires and releases the lock automatically,
whereas ReentrantLock requires explicit lock() and unlock().
3. synchronized does not support try-locking, but ReentrantLock
allows tryLock() and tryLock(timeout, TimeUnit).
4. Synchronized is unfair (no guaranteed thread order),
whereas ReentrantLock can be fair (new ReentrantLock(true))
or unfair.
5. Synchronized does not allow lock interruption, but
ReentrantLock supports lockInterruptibly() for better thread
management.
6. Synchronized uses wait() and notify(), while ReentrantLock
provides Condition variables for finer control over waiting
threads.
7. Synchronized is simpler and easier to use, while ReentrantLock is
more powerful but requires careful handling to avoid deadlocks.

Q150. What is the difference between WeakReference and

SoftReference?

tejasshah2k19@[Link]
Both WeakReference and SoftReference are part of Java's reference types
in the [Link] package, used to manage memory more efficiently by
allowing objects to be garbage collected under specific conditions. Here’s
the key difference between them:

Garbage Collection Timing

● WeakReference: Reclaimed immediately when no strong references

exist.
● SoftReference: Reclaimed only under memory pressure.

Retention Policy

● WeakReference: Short-lived, discarded aggressively.

● SoftReference: Longer-lived, retained until JVM needs memory.

Use Case

● WeakReference: Used for lookup tables, avoiding memory leaks

(e.g., caches, listeners).
● SoftReference: Used for caching data that is expensive to reload
(e.g., image caching, object pools).

Garbage Collector Behavior

● WeakReference: GC clears weak references at the earliest opportunity.

● SoftReference: GC clears soft references only when memory is low.

Likelihood of Being Collected

● WeakReference: Very high (almost immediate collection).

● SoftReference: Lower (kept until necessary to free memory)

tejasshah2k19@[Link]