Top 125 Java Interview Questions and Answers

Q: What is the difference between JDK, JRE, and JVM?

`JVM` is the runtime engine that executes Java bytecode. It is responsible for class loading, memory management, bytecode execution, and garbage collection. `JRE` includes the JVM plus the standard libraries and runtime components needed to run Java applications. `JDK` is the full development kit. It contains the JRE along with developer tools such as `javac`, `javadoc`, and debugging utilities. A simple way to explain it in an interview is: JVM runs code, JRE provides the runtime environment, and JDK provides everything required to develop, compile, and run Java applications.

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

`==` compares references for objects, which means it checks whether two variables point to the exact same object in memory. For primitive types, `==` compares actual values. `.equals()` is meant for logical equality and is often overridden by classes such as `String`, `Integer`, or domain models to compare meaningful content instead of identity. This matters a lot in collections and business logic. Two different `String` objects can have the same text, so `.equals()` returns true even though `==` may return false. The simplest distinction is that `==` checks identity for objects, while `.equals()` checks logical equality.

Java Interview Questions and Answers by Topic

Explore Java interview topics in the order candidates usually prepare them: language basics, exceptions and IO, collections, multithreading, JVM internals, modern Java features, and scenario-based decision making.

Core Java and OOP Basics

20 questions

Strings, Arrays, Exceptions and IO

20 questions

Collections Framework

25 questions

Multithreading and Concurrency

20 questions

JVM, Garbage Collection and Performance

20 questions

Java 8 Plus, Advanced and Scenario-Based

15 questions

Design Patterns and Coding Challenges

4 questions

Most Asked Java Interview Questions and Answers

These are the Java questions that come up repeatedly in screening rounds, fresher interviews, and experienced backend interviews where interviewers test both fundamentals and reasoning.

Core Java and OOP Basics

What are the main features of Java? Explain "Write Once, Run Anywhere."

Core Java and OOP Basics

What is the difference between JDK, JRE, and JVM?

Core Java and OOP Basics

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

Core Java and OOP Basics

What is the difference between String, StringBuilder, and StringBuffer?

Collections Framework

Difference between List, Set, and Map.

Collections Framework

HashMap vs Hashtable vs ConcurrentHashMap.

Multithreading and Concurrency

What is synchronization? Explain synchronized keyword.

Multithreading and Concurrency

What is Future and CompletableFuture?

JVM, Garbage Collection and Performance

Explain JVM architecture (Class Loader, Runtime Data Areas, Execution Engine).

Java 8 Plus, Advanced and Scenario-Based

What are lambda expressions? Functional interfaces?

Core Java and OOP Basics

20 questions

1. What are the main features of Java? Explain "Write Once, Run Anywhere."

Java is known for object-oriented design, platform independence, strong memory management, automatic garbage collection, rich standard libraries, multithreading support, and a mature runtime ecosystem. It was designed to make large applications easier to build and maintain across different environments.

"Write Once, Run Anywhere" means Java source code is compiled into bytecode, not directly into machine-specific instructions. That bytecode runs on the JVM, so the same compiled program can run on Windows, Linux, or macOS as long as a compatible JVM is installed. The operating system changes, but the application binary usually does not.

2. What is the difference between JDK, JRE, and JVM?

JVM is the runtime engine that executes Java bytecode. It is responsible for class loading, memory management, bytecode execution, and garbage collection. JRE includes the JVM plus the standard libraries and runtime components needed to run Java applications.

JDK is the full development kit. It contains the JRE along with developer tools such as javac, javadoc, and debugging utilities. A simple way to explain it in an interview is: JVM runs code, JRE provides the runtime environment, and JDK provides everything required to develop, compile, and run Java applications.

Aspect	JVM	JRE	JDK
Purpose	Executes bytecode	Runs Java applications	Develops and runs Java applications
Contains	Execution engine	JVM plus core libraries	JRE plus development tools
Used By	Runtime only	Application users	Developers
Examples	Memory, GC, class loading	`java` command runtime	`javac`, `javadoc`, `jar`

3. What is a platform-independent language? How does Java achieve it?

A platform-independent language allows the same program logic to run on different operating systems or hardware platforms without rewriting the source code for each one. The main goal is portability with minimal platform-specific changes.

Java achieves this by compiling source code into bytecode. That bytecode is executed by the JVM, which acts as an abstraction layer between the program and the operating system. Each platform provides its own JVM implementation, so the application stays the same while the runtime adapts to the local machine.

4. Explain the four pillars of OOP: Abstraction, Encapsulation, Inheritance, and Polymorphism.

Abstraction means exposing only the essential behavior of an object while hiding unnecessary implementation details. For example, a List interface exposes an add() method without revealing whether it uses an array or linked nodes internally.

Encapsulation means bundling data and behavior together and controlling access through methods instead of letting outside code change state freely. For example, keeping a bank account balance private and only allowing updates through a deposit() method that validates the amount.

Inheritance allows one class to reuse and extend behavior from another class, which helps model shared characteristics. For example, a Manager class can extend an Employee class to automatically inherit fields like name and methods like getSalary().

Polymorphism allows the same method call to behave differently depending on the actual object type. For example, calling draw() on a generic Shape reference might draw a Circle or a Square depending on the specific object it points to at runtime.

A practical way to summarize them is: abstraction defines what a component does, encapsulation protects how it works, inheritance enables reuse, and polymorphism allows flexible substitution.

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

== compares references for objects, which means it checks whether two variables point to the exact same object in memory. For primitive types, == compares actual values. .equals() is meant for logical equality and is often overridden by classes such as String, Integer, or domain models to compare meaningful content instead of identity.

This matters a lot in collections and business logic. Two different String objects can have the same text, so .equals() returns true even though == may return false. The simplest distinction is that == checks identity for objects, while .equals() checks logical equality.

Aspect	==	.equals()
Objects	Reference comparison	Logical/content comparison
Primitives	Value comparison	Not applicable
Override Needed	No	Often overridden
Typical Risk	Wrong equality checks for objects	Incorrect behavior if implemented badly

6. What are access modifiers in Java? Explain their scope.

Access modifiers control visibility of classes, fields, methods, and constructors. public makes a member accessible from anywhere. private restricts access to the same class only. protected allows access within the same package and also in subclasses outside the package. If no modifier is used, Java applies package-private access, which means visibility is limited to the same package.

The design goal is to use the smallest visibility needed, so internal state stays hidden and only intended behavior is exposed.

Modifier	Same Class	Same Package	Subclass Outside Package	Anywhere
`private`	Yes	No	No	No
Package-private	Yes	Yes	No	No
`protected`	Yes	Yes	Yes	No
`public`	Yes	Yes	Yes	Yes

7. What is the difference between abstract class and interface?

An abstract class is used when related classes share state or partial implementation. It can have instance variables, constructors, concrete methods, and abstract methods. An interface defines a contract that classes agree to implement. Modern Java interfaces can also contain default and static methods, but they are still primarily about capability rather than shared state.

The real distinction is design intent. Use an abstract class when subclasses share common implementation or lifecycle behavior. Use an interface when unrelated classes should follow the same contract without being forced into one inheritance chain.

Aspect	Abstract Class	Interface
State	Can hold instance state	Usually no instance state
Constructors	Yes	No
Inheritance	Single class inheritance only	Multiple interfaces allowed
Best Use	Shared base behavior	Behavior contract

8. Can a class extend multiple classes? What about implementing interfaces?

A Java class cannot extend multiple classes because Java does not support multiple inheritance for classes. This avoids ambiguity problems such as two parent classes defining the same method or conflicting state handling.

A class can implement multiple interfaces. That is how Java supports multiple behavioral contracts without allowing multiple concrete base classes. In practice, a class usually extends one parent if it needs shared implementation, and it implements one or more interfaces when it needs to express capabilities such as Comparable, Runnable, or a custom service contract.

9. What is method overloading vs method overriding?

Method overloading means defining multiple methods with the same name in the same class but with different parameter lists. It is resolved at compile time and is a form of static polymorphism. Method overriding happens when a subclass provides its own implementation of a method already defined in the parent class, and that behavior is resolved at runtime.

The easiest way to explain the difference is that overloading changes how a method is called, while overriding changes how inherited behavior executes. One is about multiple signatures in the same type, and the other is about specialized behavior in a subtype.

Aspect	Overloading	Overriding
Where	Same class	Subclass
Parameters	Must differ	Usually same signature
Binding	Compile-time	Runtime
Purpose	Convenience and API flexibility	Specialized inherited behavior

10. Explain final, finally, and finalize().

final is a keyword used to restrict change. A final variable cannot be reassigned, a final method cannot be overridden, and a final class cannot be extended. finally is a block used with exception handling to run cleanup code whether an exception occurs or not.

finalize() was a method that the garbage collector could call before reclaiming an object, but it is deprecated and should not be used for resource management because it is unpredictable and expensive. Modern Java uses try-with-resources and explicit cleanup instead of relying on finalize().

Term	Type	Purpose
`final`	Keyword	Restricts reassignment, overriding, or inheritance
`finally`	Exception block	Runs cleanup logic
`finalize()`	Method	Deprecated GC-related cleanup hook

11. What is the difference between this and super?

this refers to the current object instance. It is used to access current fields, call current methods, or pass the current object around. It is also used in constructors through this(...) to call another constructor in the same class.

super refers to the immediate parent class. It is used to access parent fields, call parent methods, or invoke the parent constructor through super(...). A simple way to explain it is: this means current object context, while super means parent class context.

12. What are constructors? Can a constructor be private?

A constructor is a special block used to initialize an object when it is created. It has the same name as the class and does not return any value, not even void. Constructors are commonly used to enforce valid initial state, inject dependencies, or set default values.

Yes, a constructor can be private. Private constructors are often used in utility classes, singleton patterns, and factory-based designs where object creation must be controlled. They matter when the class should decide how and when instances are created instead of allowing direct construction everywhere.

13. What is static keyword? Explain static variables, methods, and blocks.

The static keyword means the member belongs to the class itself rather than to individual objects. A static variable is shared across all instances, so there is one copy per class. A static method can be called without creating an object, but it cannot directly access non-static instance state.

A static block is executed once when the class is loaded and is typically used for class-level initialization. Static members are useful for shared configuration, utility functions, constants, counters, and one-time setup logic that should exist independently of any single object.

14. What is the default value of instance variables in Java?

Instance variables in Java automatically receive default values if they are not explicitly initialized. Numeric primitive types become 0 or their equivalent, boolean becomes false, char becomes the null character, and object references become null.

This rule applies to instance variables and static variables because they are part of class or object state managed by the JVM. It does not apply to local variables inside methods. Local variables must be assigned before use, otherwise compilation fails. The important distinction is between JVM-managed object state and method-local variables.

15. Explain the Java Memory Model (Stack vs Heap).

In a simple interview explanation, the stack stores method-level execution data such as local variables, method calls, and references for each thread. The heap stores objects and arrays that are created during program execution and can be shared through references.

The broader Java Memory Model is actually about how threads see reads and writes to shared memory, but interviewers often start with stack versus heap as the entry point. A safe answer is that stack memory is thread-specific and tied to call execution, while heap memory is where objects live and is managed by garbage collection.

16. What are wrapper classes? Why do we need them?

Wrapper classes are object representations of primitive types, such as Integer for int, Double for double, and Boolean for boolean. They allow primitive values to be treated as objects when the language or framework requires object behavior.

We need them because collections, generics, many utility APIs, and object-oriented operations work with objects, not primitives. Wrapper classes also provide useful helper methods for parsing, conversion, and comparison. Primitives are efficient for raw values, but wrappers are necessary when object semantics are required.

17. What is autoboxing and unboxing?

Autoboxing is the automatic conversion of a primitive type into its wrapper object, such as converting int to Integer. Unboxing is the reverse process, where Java converts a wrapper back into its primitive value when needed by an expression or assignment.

This feature reduces boilerplate, especially when working with collections, generics, and utility APIs that require objects instead of primitives. However, it can also introduce subtle issues such as NullPointerException when a null wrapper is unboxed, or unnecessary object creation in performance-sensitive code. The main trade-off is convenience versus hidden runtime cost.

18. What is the Object class? Name important methods.

Object is the root class of the Java class hierarchy, which means every Java class directly or indirectly inherits from it. Because of that, it defines the base behavior shared by all objects in the language.

Important methods include equals(), hashCode(), toString(), getClass(), clone(), wait(), notify(), and notifyAll(). The most important ones to explain are usually equals(), hashCode(), and toString() because they affect collection correctness, logging, debugging, and how domain objects behave in real applications. Concurrency-related methods like wait() and notify() are also part of that base contract.

19. What is the difference between String, StringBuilder, and StringBuffer?

String is immutable, so any modification creates a new object. StringBuilder is mutable and designed for efficient string changes in single-threaded code. StringBuffer is also mutable but synchronized, so it is thread-safe at the method level and usually slower than StringBuilder when that safety is unnecessary.

The practical answer is that String is best for fixed text or values passed around safely, StringBuilder is best for repeated concatenation in normal application code, and StringBuffer is mainly relevant when synchronized mutable string operations are specifically needed.

Aspect	String	StringBuilder	StringBuffer
Mutability	Immutable	Mutable	Mutable
Thread Safety	Safe because immutable	Not synchronized	Synchronized
Performance for Repeated Changes	Lower	High	Lower than `StringBuilder`
Typical Use	Fixed text	Single-threaded concatenation	Legacy or thread-safe mutable text

20. Why is String immutable in Java? What are its advantages?

String immutability means once a String object is created, its value cannot change. Java uses this design to improve safety, simplicity, and performance in several core areas of the platform.

Its advantages include thread safety without extra synchronization, safe use as map keys, reliable string pooling, and stronger security when values such as file paths, class names, or network addresses are passed between APIs. Because the content cannot change unexpectedly, one reference cannot silently affect another part of the program. That predictability is the main design benefit.

Strings, Arrays, Exceptions and IO

20 questions

21. How does the String pool work in Java?

The String pool is a special area where Java stores string literals so identical literal values can be reused instead of creating new objects every time. If two literals have the same content, Java can point both references to the same pooled object.

This improves memory efficiency and can also affect identity checks using ==. For example, two identical literals may reference the same pooled object, while a new string created with new String(...) creates a distinct object unless intern() is used. The key idea is reuse of immutable string instances.

22. Why is char[] preferred over String for passwords?

A char[] is often preferred for passwords because it can be cleared manually after use by overwriting the array contents. A String is immutable, which means once it is created, its content stays in memory until the garbage collector removes it, and you cannot explicitly erase the sensitive value immediately.

This does not make char[] magically secure, but it gives developers more control over the lifetime of sensitive data. The main advantage is reducing how long the secret stays exposed in memory rather than claiming perfect protection.

23. What happens when you do String s = "hello" + "world"; in a loop?

If you concatenate strings repeatedly inside a loop using String, Java may create many temporary objects because each concatenation produces a new immutable string. That increases allocation overhead and GC pressure, especially when the loop is large or the text grows gradually.

The compiler can optimize constant expressions such as "hello" + "world" outside loops, but dynamic concatenation inside loops is still expensive with plain String. StringBuilder is the preferred tool for repeated concatenation because it avoids creating unnecessary intermediate objects.

24. What is the difference between Array and ArrayList?

An array has a fixed size once created and can store either primitives or objects. ArrayList is a resizable collection that stores objects, not primitive values directly. Arrays are part of the language, while ArrayList is part of the collections framework.

ArrayList is easier to work with for dynamic data because it provides methods like add(), remove(), and contains(). Arrays are more lightweight and can be better when size is known and performance is critical. A concise distinction is that arrays are fixed-size language structures, while ArrayList is a flexible collection abstraction.

Aspect	Array	ArrayList
Size	Fixed	Resizable
Stores	Primitives or objects	Objects only
API Support	Minimal	Rich collection methods
Typical Use	Known size, low-level performance	Dynamic lists

25. How do you create an immutable class in Java?

To create an immutable class, make the class final so it cannot be subclassed, make fields private final, initialize them fully in the constructor, and do not provide setters. If a field refers to a mutable object, return defensive copies instead of exposing the original reference.

The important principle is not just preventing reassignment, but preventing outside code from mutating internal state through shared references. Types like String and LocalDate are common examples because immutability improves safety, predictability, and thread-friendly behavior.

26. What are checked and unchecked exceptions?

Checked exceptions are exceptions the compiler forces you to handle or declare, such as IOException. They represent conditions the caller is expected to anticipate explicitly. Unchecked exceptions are subclasses of RuntimeException, such as NullPointerException or IllegalArgumentException, and the compiler does not force explicit handling.

The design intent is that checked exceptions represent recoverable or expected external failure conditions, while unchecked exceptions usually represent programming errors or invalid use of an API. The distinction is about responsibility and error modeling, not just syntax.

Aspect	Checked Exception	Unchecked Exception
Compiler Handling	Must catch or declare	No mandatory handling
Base Type	`Exception` excluding `RuntimeException`	`RuntimeException`
Typical Meaning	Recoverable external issue	Programming/API misuse issue
Examples	`IOException`	`NullPointerException`

27. What is the difference between throw and throws?

throw is used inside a method body to actually create and throw an exception object at runtime. throws is used in the method signature to declare that the method may pass one or more exceptions to its caller.

So one performs the action, and the other communicates the contract. For example, throw new IllegalArgumentException(...) is used when invalid input is detected inside the method, while public void read() throws IOException tells callers they must handle or propagate that checked exception. throw is operational and throws is declarative.

28. Explain the exception hierarchy in Java.

At the top of the hierarchy is Throwable. Under it are two major branches: Error and Exception. Error represents serious JVM-level problems such as OutOfMemoryError and is usually not handled in normal application logic. Exception represents conditions applications may handle.

Within Exception, RuntimeException and its subclasses are unchecked, while most other exceptions are checked. The hierarchy separates fatal system problems from application-level problems, and then further separates checked contractual failures from unchecked programming issues.

29. What is try-with-resources? When was it introduced?

try-with-resources is a language feature that automatically closes resources such as streams, readers, database connections, or sockets when execution leaves the try block. It works with types that implement AutoCloseable, so cleanup happens even if an exception is thrown during processing.

It was introduced in Java 7. The main benefit is safer resource management with less boilerplate and fewer leaks. It is preferred over manual finally cleanup because it is shorter, clearer, and more reliable. It also makes resource ownership easier to understand in production code.

try (BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"))) {
    String line = reader.readLine();
    System.out.println(line);
}

30. Can a finally block execute if there is a return in try?

Yes, a finally block usually executes even if there is a return statement inside the try block. Java evaluates the return value first, then runs the finally block, and only after that completes the method return.

This is why finally has historically been used for cleanup. However, if the JVM terminates abruptly or the process exits forcibly, finally may not run. So the accurate answer is: normally yes, but there are exceptional situations where the process can end before finally executes.

31. What is System.exit() effect on finally?

Calling System.exit() requests JVM termination. In normal cases, once the JVM shutdown process begins, a finally block in the current flow may not complete in the way a standard return path would. That is why relying on finally after System.exit() is unsafe.

The important point is that finally is not guaranteed under all conditions. Normal control flow is one thing, but explicit process termination changes the rules because the JVM itself is being shut down.

32. How does Java handle multiple exceptions in one catch block (multi-catch)?

Java supports multi-catch, which lets you catch multiple exception types in a single catch block using the | operator. This works when the handling logic is the same for all listed exception types, so it helps reduce duplicated catch blocks with identical recovery or logging code.

It was introduced in Java 7. The caught exception variable is implicitly final in that block, so you cannot reassign it. The main benefit is improved readability and maintainability when several exceptions should be handled the same way, while still preserving clear type declarations in the signature.

33. What is serialization? How do you make a class serializable?

Serialization is the process of converting an object into a byte stream so it can be stored, transferred, or reconstructed later. In Java, a class can be made serializable by implementing the marker interface Serializable.

It is also good practice to declare a serialVersionUID to control version compatibility during deserialization. Not every field should necessarily be serialized, especially if it is derived, sensitive, or tied to runtime resources. Serialization is about object state transfer, not arbitrary object behavior.

34. What is transient keyword?

The transient keyword tells Java not to include a field in default serialization. When an object is serialized, transient fields are skipped, and when the object is deserialized, those fields get default values instead of their previous runtime values.

This is useful for sensitive data such as passwords, for derived values that can be recomputed, or for fields that should not be persisted because they depend on runtime-only resources. The key point is that transient controls serialization behavior, not general visibility or lifecycle.

35. What is reflection in Java? When is it used?

Reflection is the ability to inspect and manipulate classes, methods, fields, annotations, and constructors at runtime. It allows Java code to discover type information dynamically instead of relying only on compile-time knowledge.

It is used in frameworks such as Spring, Hibernate, dependency injection containers, testing libraries, and serialization tools. Reflection is powerful, but it also reduces type safety, can hurt performance, and can make code harder to understand. A strong interview answer presents it as a framework-building tool rather than something to use casually in everyday business logic.

36. What are the major IO classes in Java? (File, InputStream, etc.)

Java IO includes byte-based streams such as InputStream and OutputStream, character-based abstractions such as Reader and Writer, and file-related APIs such as File, Path, and Files. Streams are used to read or write data, while higher-level wrappers like BufferedReader or BufferedWriter improve efficiency.

The clearest way to explain them is by purpose: byte streams for raw binary data, character streams for text, buffering wrappers for performance, and file or path APIs for filesystem interaction. That shows an understanding of the abstraction layers rather than memorizing class names only.

37. What is the difference between Reader/Writer and InputStream/OutputStream?

InputStream and OutputStream work with raw bytes, so they are suitable for binary data such as images, PDFs, or network packets. Reader and Writer work with characters and are designed for text data with character encoding awareness.

The key difference is abstraction level. Byte streams deal with raw bytes, while character streams translate between bytes and characters. For text processing, readers and writers are usually preferred, while binary content should stay with input and output streams.

Aspect	InputStream/OutputStream	Reader/Writer
Data Type	Bytes	Characters
Best For	Binary data	Text data
Encoding Awareness	No direct text encoding handling	Yes, via character decoding/encoding
Examples	`FileInputStream`	`BufferedReader`

38. How do you read a file line by line efficiently?

A common and efficient way is to use BufferedReader or Files.lines() because both avoid loading the entire file into memory at once. They process data incrementally, which is important for large files.

BufferedReader is explicit and easy to control, while Files.lines() gives a stream-based style that works well with filtering and mapping. The real design point is that line-by-line processing reduces memory pressure and fits log files, CSV parsing, and other sequential file workloads well.

try (BufferedReader reader = Files.newBufferedReader(Path.of("app.log"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

39. What is Enum in Java? Can it implement interfaces?

An enum is a special Java type used to represent a fixed set of constants, such as days of the week, states, or roles. It provides stronger type safety and clearer domain modeling than using raw strings or integers.

Yes, an enum can implement interfaces. That is often useful when different enum constants represent values that should still participate in a common contract. Enums can also have fields, methods, and constructors, so they are full-fledged types, not just labels.

40. Explain varargs (...) and its limitations.

Varargs allow a method to accept a variable number of arguments of the same type. Inside the method, Java treats them like an array. This is useful for APIs where callers may pass any number of values, such as formatting utilities or helper methods.

The limitations are that only one varargs parameter is allowed, it must be the last parameter in the method signature, and overuse can make overloaded methods ambiguous. Varargs also create an array under the hood, so there can be some allocation cost.

Collections Framework

25 questions

41. What is the Java Collections Framework? Name root interfaces.

The Java Collections Framework is a unified architecture for storing, accessing, and manipulating groups of objects. It provides standard interfaces, concrete implementations, iterators, and utility algorithms so developers do not need to build common data structures from scratch for every problem.

The main root interfaces are Collection and Map. Under Collection, the most common subinterfaces are List, Set, and Queue, with Deque extending Queue. The important part is to reason from abstractions first instead of jumping straight to specific classes.

42. Difference between List, Set, and Map.

List stores elements in an ordered sequence and allows duplicates. Set stores unique elements and is primarily used when uniqueness matters more than positional access. Map stores key-value pairs, where keys are unique and values are looked up through those keys.

The practical way to choose is by problem fit: use List when order or indexing matters, Set when duplicates must be prevented, and Map when fast lookup by a business key is needed. That shows understanding beyond repeating textbook definitions.

Aspect	List	Set	Map
Stores	Elements	Unique elements	Key-value pairs
Duplicates	Allowed	Not allowed	Keys unique
Ordering	Usually positional	Implementation-dependent	Implementation-dependent
Typical Use	Ordered collection	Uniqueness	Lookup by key

43. ArrayList vs LinkedList — when to use which?

ArrayList is usually the default choice because it offers fast random access, good cache locality, and efficient append operations. LinkedList uses nodes connected by references, so it can be useful when frequent insertions or removals happen around known positions and random access is not important.

In real applications, ArrayList wins far more often than people expect because CPUs favor contiguous memory. I only choose LinkedList when the access pattern clearly matches queue-like or structural editing behavior and I am not relying on index-based access heavily.

Aspect	ArrayList	LinkedList
Structure	Dynamic array	Doubly linked list
Index Access	Fast	Slow
Middle Updates	Costly shift	Cheaper after locating node
Default Choice	Usually yes	Only for specific patterns

44. HashMap vs Hashtable vs ConcurrentHashMap.

HashMap is not thread-safe and is the normal choice for single-threaded or externally coordinated use. Hashtable is thread-safe because its methods are synchronized, but it is a legacy design and often scales poorly under contention. ConcurrentHashMap is built for concurrent access and allows better throughput through more efficient coordination strategies.

The interview answer should focus on concurrency semantics and modern preference. HashMap is the default general-purpose map, Hashtable is mostly legacy, and ConcurrentHashMap is the preferred choice when many threads need shared map access with better performance.

Aspect	HashMap	Hashtable	ConcurrentHashMap
Thread Safety	No	Yes	Yes
Null Support	Allows one null key and null values	No null key or value	No null key or value
Scalability	High single-threaded	Lower under contention	Better concurrent scalability
Modern Use	Very common	Legacy	Preferred concurrent map

45. Internal working of HashMap (buckets, hashing, tree bins).

A HashMap stores entries in an internal array of buckets. When a key is inserted, Java calculates its hash code, applies additional bit mixing, and uses that result to choose a bucket index. If two keys land in the same bucket, a collision occurs.

Collisions were traditionally stored in linked lists. In Java 8 and later, when a bucket becomes too crowded and the table is large enough, that collision chain can be converted into a balanced tree structure called a tree bin. This improves worst-case lookup behavior and is one of the major performance improvements in modern HashMap internals.

46. What is load factor and rehashing in HashMap?

The load factor controls how full a HashMap can become before resizing. The default load factor is 0.75, which balances memory use and lookup speed. When the number of entries crosses capacity * loadFactor, the map resizes.

Rehashing means creating a larger internal bucket array and redistributing existing entries according to the new capacity. That operation is expensive compared with normal insertion, which is why pre-sizing a map can improve performance when you already know the expected number of entries in advance.

47. HashSet vs LinkedHashSet vs TreeSet.

HashSet stores unique elements with fast average-case lookup and no guaranteed iteration order. LinkedHashSet also uses hashing but preserves insertion order, which makes iteration predictable. TreeSet maintains elements in sorted order using a tree-based structure and therefore has O(log n) operations instead of the average O(1) behavior typical of hash-based sets.

The right interview framing is trade-offs: HashSet for raw uniqueness and speed, LinkedHashSet for uniqueness plus stable iteration order, and TreeSet for uniqueness plus sorted traversal and range-style behavior. The best choice depends on whether order, sorting, or raw lookup performance matters most.

Aspect	HashSet	LinkedHashSet	TreeSet
Order	No guaranteed order	Insertion order	Sorted order
Performance	Fast average	Fast average with small overhead	O(log n)
Duplicates	No	No	No
Best For	Fast membership checks	Stable order	Sorted unique values

48. HashMap vs TreeMap vs LinkedHashMap.

HashMap is optimized for fast average-case lookup and does not guarantee iteration order. LinkedHashMap extends that behavior by preserving insertion order or access order, which is useful for predictable traversal or cache-like behavior. TreeMap stores keys in sorted order using a self-balancing tree.

The collection choice depends on whether you care most about raw average lookup performance, predictable traversal order, or sorted keys. In interviews, that reasoning matters more than just naming which one uses hashing and which one uses a tree.

Aspect	HashMap	LinkedHashMap	TreeMap
Ordering	No guarantee	Insertion or access order	Sorted by key
Performance	Fast average	Fast average with order overhead	O(log n)
Typical Use	General lookup	Stable order or LRU behavior	Sorted key operations
Null Key	One allowed	One allowed	Usually not with natural ordering

49. How does equals() and hashCode() affect collections?

Hash-based collections rely on both equals() and hashCode() to decide how objects are stored and found. If two objects are logically equal, they must return the same hashCode(). Otherwise a map or set may fail to find the object correctly or may allow duplicates that should not exist logically.

This is especially important when custom domain objects are used as keys in HashMap or elements in HashSet. In interview answers, I always say that equals() defines logical identity and hashCode() must stay consistent with that identity for hash-based collections to behave correctly.

50. What is fail-fast vs fail-safe iterator?

A fail-fast iterator throws ConcurrentModificationException if it detects structural modification of the collection while iterating, except through the iterator’s own safe methods such as remove(). Many standard collections like ArrayList use this behavior as an early warning mechanism.

A fail-safe style iterator, often seen in concurrent collections such as CopyOnWriteArrayList, iterates over a snapshot or weakly consistent view instead of failing immediately. The key difference is that fail-fast detects unsafe modification aggressively, while fail-safe prioritizes continued iteration in concurrent scenarios.

Aspect	Fail-Fast	Fail-Safe / Weakly Consistent
Reaction to Modification	Throws exception	Continues with snapshot/relaxed view
Typical Collections	`ArrayList`, `HashMap`	`CopyOnWriteArrayList`, concurrent collections
Goal	Detect unsafe changes early	Allow concurrent iteration
Trade-Off	Stricter behavior	May not reflect latest updates immediately

51. How to make a collection thread-safe?

One option is to wrap a collection with synchronized utilities such as Collections.synchronizedList() or Collections.synchronizedMap(). That makes individual operations thread-safe by serializing access through a common monitor.

Another option is to use concurrent collections such as ConcurrentHashMap, CopyOnWriteArrayList, or ConcurrentLinkedQueue, which are often better for scalability and concurrent iteration patterns. In interviews, the stronger answer is not just "use synchronized," but "choose a synchronization strategy that matches the read-write pattern, iteration needs, and contention level." That shows practical understanding rather than a one-size-fits-all answer.

52. What is CopyOnWriteArrayList?

CopyOnWriteArrayList is a thread-safe list where every structural modification creates a new copy of the internal array. This makes write operations more expensive, but it allows iteration and reads to happen without the typical contention of locking around every traversal.

It is a good fit when reads are frequent and writes are rare, such as listener registries or configuration snapshots. In interviews, it is important to say that it is not a general replacement for ArrayList, because the cost of copying makes it unsuitable for write-heavy workloads.

53. How to sort a List? Comparable vs Comparator.

A List can be sorted using Collections.sort(list) or list.sort(comparator). If the element type implements Comparable, Java uses that natural ordering. If you need a custom rule, you provide a Comparator.

Comparable is defined inside the class and represents one default ordering. Comparator is external and supports multiple sort strategies. In interviews, I usually say Comparable is ideal when the type has a natural business order, while Comparator is better when sorting depends on context such as name, date, or score.

Aspect	Comparable	Comparator
Defined In	The class itself	External class/lambda
Main Method	`compareTo()`	`compare()`
Ordering Count	One natural order	Many custom orders
Typical Use	Default sort	Scenario-specific sort

54. What is PriorityQueue?

PriorityQueue is a queue that orders elements by priority rather than strict insertion order. The element removed first is the one with the highest priority according to natural ordering or a supplied comparator, which in Java usually means the smallest element comes out first by default.

It is commonly used in scheduling, shortest-path algorithms, ranking problems, and task prioritization. In interviews, it is good to point out that iteration over a PriorityQueue is not guaranteed to show sorted order even though removal follows priority rules.

55. How to remove duplicates from an ArrayList while preserving order?

A common approach is to pass the list into a LinkedHashSet, because a set removes duplicates and LinkedHashSet preserves insertion order. Then, if a list is still needed, create a new ArrayList from that set.

This is a strong interview answer because it balances correctness and simplicity. It keeps the first occurrence of each value and removes later duplicates without sorting the data or writing manual bookkeeping code. If duplicates must be removed using custom business rules rather than exact equality, then a manual loop with a tracking set may be more appropriate.

List<String> values = Arrays.asList("A", "B", "A", "C", "B");
List<String> uniqueInOrder = new ArrayList<>(new LinkedHashSet<>(values));

56. Explain WeakHashMap.

WeakHashMap stores keys using weak references. If a key is not referenced strongly anywhere else in the application, it becomes eligible for garbage collection, and the corresponding entry in the map can disappear automatically.

This makes it useful for caches, metadata associations, and support structures where the map should not prevent unused keys from being collected. The important interview caveat is that entry removal depends on garbage collection timing, so it should only be used when that non-deterministic lifecycle is acceptable.

57. What is IdentityHashMap?

IdentityHashMap compares keys using reference equality with == instead of logical equality with equals(). That means two objects with identical content are still treated as different keys unless they are literally the same object instance.

It is a niche collection used in object graph processing, serialization internals, proxy tracking, and scenarios where identity matters more than logical value equality. In interviews, I make it clear that it is not a normal replacement for HashMap; it is for special cases where object identity is the design requirement.

58. How does LinkedHashMap maintain order?

LinkedHashMap combines a hash table with a linked structure that connects entries. That extra linked structure preserves iteration order while still keeping the normal hash-based lookup behavior. By default, it maintains insertion order, but it can also be configured for access order so recently accessed entries move to the end.

This is why LinkedHashMap is commonly used to build simple LRU-style caches. It keeps hashing performance while adding predictable traversal behavior, which is something plain HashMap does not guarantee. In interviews, it is useful to mention both insertion order and access order explicitly.

59. What collection for LRU cache implementation?

LinkedHashMap is a common choice for a simple in-memory LRU cache because it can maintain access order and lets you override removeEldestEntry() to evict old entries automatically when the cache exceeds a size limit.

That answer works well in interviews because it shows both API knowledge and design reasoning. The important detail is enabling access-order mode, not just insertion order. For more advanced caching with expiration, size weighting, and statistics, dedicated libraries may be better, but for a straightforward Java collections answer, LinkedHashMap is usually the expected solution.

Map<Integer, String> lru = new LinkedHashMap<>(16, 0.75f, true) {
    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
        return size() > 100;
    }
};

60. Difference between ArrayDeque and Stack.

Stack is a legacy class that extends Vector, so it carries older synchronized-list behavior that is often unnecessary today. ArrayDeque is a more modern double-ended queue implementation that supports stack operations such as push(), pop(), and peek() efficiently in most single-threaded use cases.

In interviews, I usually say that ArrayDeque is preferred for stack behavior unless legacy API compatibility specifically requires Stack. The broader point is that modern Java favors deque-based stack usage instead of older vector-based designs. Mentioning both design age and performance trade-offs makes the answer feel much stronger.

Aspect	ArrayDeque	Stack
Design	Modern deque	Legacy `Vector`-based class
Performance	Usually better	More overhead
Thread Safety	Not synchronized	Synchronized via `Vector`
Modern Preference	Preferred	Rarely recommended

61. What are concurrent collections in java.util.concurrent?

Concurrent collections are data structures designed for safe and scalable access by multiple threads. Examples include ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, BlockingQueue implementations, and ConcurrentSkipListMap.

The main benefit is that they provide thread safety with better concurrency behavior than coarse synchronized wrappers in many workloads. In interviews, I usually explain them as specialized tools where the collection itself understands concurrency patterns such as lock partitioning, non-blocking access, blocking coordination, or snapshot-style iteration. That shows you know they solve different concurrency problems, not just "thread safety" in a generic sense.

62. How to create an immutable collection?

You can create an unmodifiable view using methods such as Collections.unmodifiableList(...), or in newer Java versions use factory methods like List.of(...), Set.of(...), and Map.of(...) for immutable collections.

The distinction matters. An unmodifiable wrapper prevents modification through that reference, but if the original backing collection changes elsewhere, the view reflects those changes. Truly immutable collections created directly through immutable factories do not rely on a separately mutable backing structure. That nuance makes for a stronger interview answer because it shows you understand the difference between "cannot modify here" and "cannot modify anywhere."

63. What is the time complexity of common operations in major collections?

ArrayList gives O(1) index access and amortized O(1) append, but middle insertion or removal is O(n). LinkedList has O(n) access because it must traverse nodes, while structural updates around a located node are cheap. HashMap gives average O(1) put and get, and TreeMap gives O(log n) because it maintains sorted order.

The key interview point is not reciting Big O blindly, but connecting complexity to structure: arrays favor access, linked structures favor certain edits, hashing favors average lookup, and trees favor sorted operations.

64. How does TreeMap maintain sorting?

TreeMap maintains sorting by storing entries in a self-balancing Red-Black tree. Every insertion, removal, or lookup walks that tree structure while preserving ordering constraints and balancing properties.

This is why operations are typically O(log n) and why keys must be comparable through natural ordering or a Comparator. In interviews, it is good to mention that TreeMap is chosen not because it is faster than HashMap, but because it supports sorted traversal, range queries, and navigation methods such as firstKey(), lastKey(), and submaps.

65. Scenario: Store unique elements with fast lookup — which collection?

The most common answer is HashSet because it enforces uniqueness and provides fast average-case membership checks. If insertion order also matters, I would choose LinkedHashSet. If sorted order matters, I would choose TreeSet and accept the O(log n) cost.

The strongest interview answer is not just naming HashSet, but explaining the requirement mapping: uniqueness points to a set, fast average lookup points to hashing, and order requirements determine whether HashSet, LinkedHashSet, or TreeSet is the better fit. That makes the answer sound like a design choice rather than a memorized fact.

Multithreading and Concurrency

20 questions

66. What is a thread? How to create one in Java?

A thread is an independent path of execution inside a process. In Java, multiple threads can run concurrently and share heap data while each thread has its own call stack. Threads are used to improve responsiveness, parallelize work, or handle multiple tasks at the same time.

You can create a thread by extending Thread, implementing Runnable, or using higher-level concurrency utilities such as ExecutorService. In interviews, I usually add that directly creating raw threads is less common in modern code than using executor-based task submission.

67. Runnable vs Callable vs Thread.

Thread represents the actual execution unit. Runnable is a task with no return value and no checked exception in its method signature. Callable is a task that can return a result and throw checked exceptions. In modern Java design, Runnable and Callable describe work, while executors manage thread creation and scheduling.

The clean interview answer is that you usually implement Runnable or Callable, then submit those tasks to an ExecutorService instead of subclassing Thread unless you have a very specific reason.

Aspect	Thread	Runnable	Callable
Represents	Execution unit	Task	Task
Return Value	No	No	Yes
Checked Exceptions	No special support	No	Yes
Modern Preference	Lower-level	Common	Common for results

68. What is the difference between start() and run()?

start() creates a new thread of execution and eventually invokes the thread’s run() method on that new thread. Calling run() directly does not create a new thread; it simply runs the method like a normal method call on the current thread.

This question looks simple, but it checks whether you understand actual concurrency versus just the method names. A correct interview answer always emphasizes that start() gives asynchronous execution on a new thread, while direct run() does not. If you call run() manually, the code is still single-threaded unless another thread was created elsewhere.

69. What is synchronization? Explain synchronized keyword.

Synchronization is the mechanism used to control access to shared mutable state so that multiple threads do not interfere with one another or observe inconsistent updates. In Java, the synchronized keyword ensures that only one thread at a time can execute a synchronized block or method guarded by the same monitor.

It also establishes important memory visibility guarantees. That means writes by one thread become visible to another thread when synchronization boundaries are crossed correctly. In interviews, I mention both mutual exclusion and visibility because synchronization is about both.

70. What is volatile? When to use it?

volatile tells the JVM that a variable’s value may be changed by multiple threads and that reads and writes to it must have specific visibility guarantees. A write to a volatile variable by one thread becomes visible to other threads reading that variable.

It is useful for simple state flags such as shutdown indicators or configuration references that are read often and written occasionally. It does not make compound actions atomic, so it is not a replacement for synchronization when multiple steps such as read-modify-write must happen safely together.

71. What is a deadlock? How to avoid it?

A deadlock happens when two or more threads are waiting on each other forever, usually because they each hold one lock and are waiting to acquire another lock held by the other thread. As a result, no thread can proceed.

Common avoidance strategies include acquiring locks in a consistent global order, reducing nested locking, using timeouts with explicit lock APIs, and designing with higher-level concurrency utilities when possible. In interviews, I usually say deadlock prevention starts with predictable lock ordering and simpler shared-state design.

72. Explain wait(), notify(), and notifyAll().

wait() causes the current thread to release the monitor and pause until another thread notifies it. notify() wakes one waiting thread, while notifyAll() wakes all waiting threads on that same monitor. These methods belong to Object because every object can act as a monitor in Java synchronization.

They must be used inside synchronized contexts that lock the same monitor. In interviews, it helps to mention that higher-level constructs like BlockingQueue or CountDownLatch are often preferred today because they are easier to reason about correctly.

73. What is ExecutorService? Name thread pool types.

ExecutorService is a higher-level API for managing asynchronous task execution. Instead of creating and managing threads manually, you submit tasks to an executor, and it handles scheduling, pooling, queuing, and lifecycle concerns.

Common thread pool types include fixed thread pools, cached thread pools, single-thread executors, scheduled thread pools, and custom ThreadPoolExecutor configurations. In interviews, I position ExecutorService as the standard abstraction because it separates task submission from thread management, improves resource control, and makes shutdown behavior much easier to handle in real applications.

74. What is Future and CompletableFuture?

Future represents the result of an asynchronous computation that may complete later. It allows you to check completion, wait for a result, or cancel the task, but its composition features are limited and it often leads to blocking code.

CompletableFuture extends that model by supporting non-blocking composition, chaining, combination of multiple asynchronous operations, and explicit success or failure pipelines. In interviews, the strongest answer is that Future is basic async result handling, while CompletableFuture supports building richer asynchronous workflows where tasks can be transformed, combined, and recovered cleanly.

Aspect	Future	CompletableFuture
Basic Async Result	Yes	Yes
Chaining	Limited	Rich composition support
Non-blocking Callbacks	No built-in flow style	Yes
Typical Use	Simple task result	Async pipelines

75. Difference between synchronized and ReentrantLock.

synchronized is built into the language and is simple to use for mutual exclusion and visibility. ReentrantLock is an explicit lock implementation from java.util.concurrent.locks that offers more flexibility, such as timed lock attempts, interruptible waits, and fair locking options.

In interviews, I usually say synchronized is preferred when simplicity is enough, while ReentrantLock is useful when the concurrency requirement needs advanced lock control. The trade-off is readability versus flexibility. A strong answer also mentions that ReentrantLock requires manual unlock handling, usually inside a finally block.

Aspect	`synchronized`	`ReentrantLock`
Syntax	Language keyword	Explicit API
Advanced Features	Limited	Timed, interruptible, fairness options
Manual Unlock Needed	No	Yes, usually in `finally`
Best For	Simple locking	Advanced coordination

76. What is CountDownLatch and CyclicBarrier?

CountDownLatch allows one or more threads to wait until a counter reaches zero. It is typically used when one thread must wait for several other tasks to finish before proceeding. Once the count reaches zero, the latch cannot be reset.

CyclicBarrier allows a group of threads to wait for each other at a common barrier point and can be reused across cycles. In interviews, I explain that a latch is one-way coordination toward completion, while a barrier is reusable rendezvous coordination among peer threads.

Aspect	CountDownLatch	CyclicBarrier
Resettable	No	Yes
Typical Use	Wait for tasks to finish	Synchronize phases of work
Direction	One-way countdown	Peer rendezvous
Reuse	Single use	Reusable

77. Explain Java Memory Model (JMM) and happens-before.

The Java Memory Model defines how threads interact through memory, including when one thread’s writes become visible to another. It exists so that concurrency behavior remains well-defined even with compiler and CPU optimizations.

happens-before is the key relationship in the JMM. If one action happens-before another, then the effects of the first are guaranteed to be visible to the second. Synchronization, volatile writes and reads, thread start, and thread join all create happens-before relationships. In interviews, that is the cleanest way to explain visibility guarantees.

78. What are thread-local variables?

Thread-local variables provide each thread with its own independent copy of a value. Even though the variable object is shared conceptually, each thread sees a separate value, which avoids normal shared-state interference.

They are useful for request-scoped context, per-thread formatters, correlation IDs, or other data that should not be shared across threads. In interviews, I also mention that thread-locals must be used carefully in thread pools because values can leak between reused threads if they are not cleaned up properly.

79. How does ConcurrentHashMap achieve concurrency?

ConcurrentHashMap achieves concurrency by allowing multiple threads to operate on different parts of the map without forcing every operation through a single global lock. Modern implementations rely on efficient internal coordination strategies and support high read concurrency with controlled synchronization only where necessary.

The key interview point is not memorizing every internal detail, but explaining the design goal: more scalable concurrent access than Hashtable or a fully synchronized wrapper. That is why it is a standard choice for shared maps in multi-threaded applications.

80. What is Lock interface and its advantages?

The Lock interface provides an explicit locking API for concurrency control. Implementations such as ReentrantLock allow programmers to lock and unlock manually rather than relying only on synchronized blocks or methods.

Its advantages include timed lock acquisition, interruptible waiting, optional fairness, and more flexible condition handling through Condition objects. In interviews, I usually say the Lock API is valuable when concurrency control needs more features than synchronized offers, but it requires disciplined cleanup because forgetting to unlock causes serious problems. That balance of flexibility and responsibility is the main design trade-off.

81. Explain producer-consumer problem.

The producer-consumer problem is a classic concurrency scenario where one or more producer threads create work items and one or more consumer threads process them. The challenge is coordinating access to the shared buffer so producers do not overfill it and consumers do not read from it when empty.

In modern Java, the best practical answer is to use a BlockingQueue, because it handles waiting and wake-up behavior safely. The interview goal is to show you understand coordination, backpressure, and safe communication between concurrent components.

82. What are virtual threads (Project Loom / Java 21+)?

Virtual threads are lightweight threads managed by the Java runtime rather than mapped one-to-one with operating system threads. They make it much easier to write high-concurrency code using simple thread-per-task style without the resource cost of creating huge numbers of platform threads.

They are especially useful for IO-bound applications such as servers that spend a lot of time waiting on network or database operations. In interviews, I frame them as a major simplification for scalable concurrency, because they reduce the need for overly complex async code in many cases.

83. What is thread starvation and livelock?

Thread starvation happens when a thread never gets enough CPU time or lock access to make progress because other threads keep winning. Livelock happens when threads remain active and keep responding to each other, but no useful progress is made because they continually back off or retry in a coordinated way.

In interviews, I distinguish them from deadlock by saying starvation is unfair progress denial, livelock is active but useless motion, and deadlock is complete waiting with no movement at all.

84. How to stop a thread gracefully?

The preferred approach is cooperative cancellation. A thread should regularly check a cancellation signal such as a volatile boolean, thread interruption status, or both, and then exit cleanly after finishing or rolling back safe work.

Using deprecated methods like stop() is unsafe because they can leave shared state inconsistent. In interviews, I normally say the thread should honor interruption, release resources properly, and exit through normal control flow rather than being killed abruptly. That shows you understand thread lifecycle management as a coordination problem, not just a command to terminate execution instantly.

85. What is ThreadLocalRandom?

ThreadLocalRandom is a random number generator designed for concurrent environments. Each thread gets its own internally managed generator, which reduces contention compared with sharing one global Random instance across many threads.

It is useful in high-concurrency code where frequent random generation is needed, such as simulations, load distribution, retry jitter, or parallel processing. In interviews, the main point is that it improves scalability by avoiding shared random-state contention. It is not mainly about better randomness quality, but about better concurrent performance and simpler multi-threaded usage.

JVM, Garbage Collection and Performance

20 questions

86. Explain JVM architecture (Class Loader, Runtime Data Areas, Execution Engine).

At a high level, JVM architecture includes the class loader subsystem, runtime data areas, and execution engine. The class loader loads .class files into memory. Runtime data areas include structures such as the heap, method area or metaspace, Java stacks, PC registers, and native method stacks.

The execution engine interprets or compiles bytecode into machine-level instructions, often with JIT optimization. Garbage collection and other runtime services operate alongside this process. In interviews, I keep the explanation layered: loading classes, storing runtime state, and executing managed code.

87. What are different class loaders in Java?

The main built-in class loaders are the bootstrap class loader, platform class loader, and application class loader. The bootstrap loader loads core Java classes. The platform loader loads platform-level modules and standard extension-like libraries. The application loader loads classes from the application classpath.

In interviews, it helps to mention parent delegation. A class loader typically asks its parent to load a class first before attempting to load it itself, which helps maintain consistency and security for core platform classes. That is why application code normally cannot accidentally replace critical JDK classes with custom implementations.

88. What is JIT compiler?

The JIT, or Just-In-Time compiler, is part of the JVM execution engine. It identifies frequently executed bytecode paths and compiles them into native machine code at runtime so later executions can run faster than pure interpretation.

This is one reason Java applications often have a warm-up period before reaching peak performance. In interviews, I explain that Java gains portability through bytecode and then regains performance through runtime compilation and optimization based on real execution behavior. That answer shows you understand how Java balances platform independence with practical runtime speed.

89. Explain Garbage Collection process.

Garbage collection is the process of identifying objects that are no longer reachable by the application and reclaiming their memory automatically. Instead of developers freeing memory manually, the JVM tracks object reachability starting from GC roots and removes objects that can no longer be reached.

The process involves marking live objects, identifying reclaimable ones, and then reclaiming or compacting memory depending on the collector. In interviews, the main message is that GC automates memory reclamation, but it still has performance characteristics and tuning implications.

90. What are GC roots?

GC roots are the starting points the JVM uses to determine which objects are still reachable. Common roots include local variables on thread stacks, static fields, active threads, and references held by native code.

If an object can be reached directly or indirectly from a GC root, it is considered live. If it cannot be reached, it becomes eligible for garbage collection. In interviews, I explain GC roots as the anchor points for reachability analysis rather than saying the collector scans every object blindly.

91. Generations in GC (Young, Old, Perm/Metaspace).

Generational garbage collection is based on the observation that most objects die young. The young generation holds newly created objects, and frequent minor GCs clean it quickly. Objects that survive enough collections are promoted to the old generation, where major or mixed collection work happens less frequently.

Older JVM discussions mention PermGen, but modern Java uses Metaspace instead. Metaspace stores class metadata outside the traditional heap. In interviews, I focus on the young versus old generation lifecycle and then mention the PermGen-to-Metaspace change as a platform evolution point.

92. Name major Garbage Collectors (G1, ZGC, Shenandoah, etc.).

Major Java garbage collectors include Serial GC, Parallel GC, G1 GC, ZGC, and Shenandoah. Serial and Parallel collectors are older and simpler. G1 became the default for many modern Java versions because it balances throughput and pause behavior for general workloads.

ZGC and Shenandoah are designed for very low pause times, especially in large-heap applications. In interviews, I usually say collector choice depends on workload goals such as throughput, latency, heap size, and pause-time sensitivity rather than naming one collector as universally best.

93. What is Stop-The-World (STW)?

Stop-The-World is a pause in which application threads are temporarily suspended so the JVM can perform certain runtime operations, most notably phases of garbage collection. During that pause, the application is not making normal business-progress work.

Not all GC work is entirely stop-the-world in the same way, and modern collectors try to minimize pause duration, but some STW phases still exist. In interviews, the key explanation is that pause time affects latency, so GC tuning is often as much about predictability as raw throughput.

94. How to tune JVM memory (heap size, etc.)?

JVM memory tuning usually starts with understanding the workload, measuring GC behavior, and then adjusting heap-related settings such as initial heap size, maximum heap size, and collector-specific parameters. You do not tune blindly; you tune based on evidence from GC logs, profiling, and production metrics.

A solid interview answer mentions goals first: lower pause times, improved throughput, or reduced memory pressure. Then explain that heap sizing, allocation rate, object lifetime, and collector choice all interact, so tuning is both a runtime and application-level exercise.

95. What is Metaspace vs PermGen?

PermGen was the older JVM area used to store class metadata, and it had a fixed-size memory model that often caused tuning pain. Metaspace replaced PermGen in Java 8 and stores class metadata in native memory rather than in a fixed part of the Java heap.

This change reduced many of the common PermGen-related issues and made class-metadata memory management more flexible. In interviews, I usually summarize it simply: PermGen was the old metadata area, Metaspace is the newer native-memory-based replacement.

Aspect	PermGen	Metaspace
Introduced In	Older JVMs	Java 8+
Storage	Part of JVM-managed memory region	Native memory
Sizing Model	Fixed/tuned region	More flexible growth
Status	Removed	Current approach

96. What causes OutOfMemoryError and StackOverflowError?

OutOfMemoryError happens when the JVM cannot allocate required memory, often due to heap exhaustion, metaspace exhaustion, direct buffer pressure, or memory leaks. StackOverflowError happens when a thread’s stack grows beyond its limit, usually because of uncontrolled recursion or very deep call chains.

In interviews, I explain that one is a heap or runtime memory-capacity problem, while the other is a call-stack depth problem. That distinction is important because the debugging path is very different for each. One usually points to retained memory or allocation pressure, while the other usually points to recursive logic or unbounded nested calls.

97. Explain finalize() method and why it’s deprecated.

finalize() was a method the JVM could call before reclaiming an object, but it was never a reliable way to release resources. Execution timing was unpredictable, it hurt performance, and it could even delay garbage collection or resurrect objects in problematic ways.

It is deprecated because modern Java encourages explicit resource management through try-with-resources, AutoCloseable, and clear lifecycle handling. In interviews, the right answer is not just that it is deprecated, but that it was unreliable by design for critical cleanup.

98. What is String.intern()?

String.intern() returns a canonical representation of the string from the string pool. If an equivalent string is already present in the pool, the pooled reference is returned. Otherwise, the string is added to the pool and that pooled reference is returned.

It can reduce duplicate string memory in some cases, but it should be used carefully because pooling has its own memory and lookup costs. In interviews, I frame it as a specialized optimization and identity-normalization tool, not something to call casually everywhere.

99. How does object creation work in JVM?

When you create an object with new, the JVM first checks whether the class is loaded and initialized. Then it allocates memory on the heap, assigns default values to fields, runs field initializers and constructors, and finally returns a reference to the created object.

At runtime, allocation is often very optimized, especially in the young generation, and may use thread-local allocation buffers. In interviews, I usually answer at two levels: language-level constructor execution and runtime-level heap allocation managed by the JVM.

100. What is escape analysis?

Escape analysis is a JVM optimization technique that determines whether an object created inside a method escapes that method or thread. If the JVM can prove it does not escape, it may optimize allocation, possibly by keeping the object on the stack conceptually or even eliminating the allocation entirely.

The practical interview point is that modern JVMs can optimize object-heavy code more aggressively than many developers expect. It is one reason naive assumptions about every object always becoming a long-lived heap cost are not always correct.

101. Difference between minor and major GC.

Minor GC primarily cleans the young generation, where short-lived objects are created frequently. It is usually faster and happens more often. Major GC, or old-generation-focused collection, deals with older objects and is typically heavier because those objects live longer and are more expensive to analyze or compact.

Depending on the collector, the terminology can vary slightly, but the interview-safe explanation is that minor GC targets newly created short-lived objects, while major or old-generation GC handles longer-lived memory and tends to have a larger performance impact.

102. How to monitor GC (tools like jstat, VisualVM)?

Garbage collection can be monitored using tools such as jstat, VisualVM, Java Flight Recorder, Mission Control, and GC logs. These tools help you observe allocation rate, heap usage, collection frequency, pause times, and promotion behavior between generations.

In interviews, I explain that GC tuning begins with measurement. You first confirm whether the problem is high allocation churn, long pauses, memory leaks, or collector misconfiguration, and then tune based on real data rather than assumptions. Mentioning logs, live metrics, and heap analysis together makes the answer feel practical and production-oriented.

103. What is java.lang.OutOfMemoryError: GC overhead limit exceeded?

This error means the JVM is spending too much time doing garbage collection while recovering too little memory. In other words, the application is stuck in heavy GC activity but still cannot free enough space to make useful progress.

It often points to memory leaks, very tight heap sizing, or object churn that the JVM cannot keep up with. In interviews, I describe it as a "GC is working hard but losing" situation, which clearly separates it from a single immediate allocation failure.

104. Explain strong, soft, weak, and phantom references.

A strong reference is the normal Java reference type, and as long as a strong reference exists, the object is not eligible for garbage collection. A soft reference allows reclamation when memory is low and is sometimes used for memory-sensitive caching. A weak reference allows collection as soon as there are no strong references left.

A phantom reference is even weaker and is mainly used for advanced cleanup or tracking after finalization-style reachability changes, typically with a reference queue. In interviews, the simplest framing is to explain them by how strongly they prevent collection.

Reference Type	Collection Behavior	Typical Use
Strong	Object kept alive	Normal application references
Soft	Collected under memory pressure	Memory-sensitive cache ideas
Weak	Collected when no strong refs remain	Canonical maps, metadata
Phantom	Post-mortem tracking with queue	Advanced cleanup coordination

105. What is class loading process (loading, linking, initialization)?

Class loading starts with loading, where the JVM finds the class definition and creates the runtime representation. Next comes linking, which includes verification, preparation, and resolution. Verification checks correctness, preparation allocates memory for class variables, and resolution turns symbolic references into direct references when needed.

Initialization is the final stage, where static initializers and static field assignments execute. In interviews, it helps to present it as a three-stage lifecycle: load the class, connect and verify it, then run its class-level initialization logic.

Java 8 Plus, Advanced and Scenario-Based

15 questions

106. What are lambda expressions? Functional interfaces?

Lambda expressions provide a concise way to represent behavior as data, especially when an interface has a single abstract method. That kind of interface is called a functional interface. Examples include Runnable, Comparator, and interfaces marked with @FunctionalInterface.

Lambdas make code more expressive for callbacks, collection processing, streams, and asynchronous work. In interviews, I usually say lambdas are Java’s way of passing behavior more cleanly, and functional interfaces are the contract that makes that syntax possible. The important design idea is that functions become first-class inputs to APIs without adding a new function type to the language.

Comparator<String> byLength = (a, b) -> Integer.compare(a.length(), b.length());
List<String> names = Arrays.asList("Java", "Go", "Python");
names.sort(byLength);

107. Explain Streams API. Intermediate vs terminal operations.

The Streams API provides a declarative way to process data collections with operations such as filtering, mapping, sorting, grouping, and reducing. A stream describes a pipeline of transformations rather than manual loop-by-loop control flow.

Intermediate operations such as filter(), map(), and sorted() return another stream and are typically lazy. Terminal operations such as collect(), forEach(), reduce(), and count() trigger actual execution of the pipeline. In interviews, I explain streams as data-processing pipelines with lazy composition and explicit terminal execution. That distinction matters because nothing really happens until a terminal step consumes the pipeline.

Aspect	Intermediate Operation	Terminal Operation
Returns	Another stream	Final result or side effect
Execution	Usually lazy	Triggers pipeline execution
Examples	`map()`, `filter()`	`collect()`, `count()`
Pipeline Role	Builds transformation chain	Consumes the chain

108. What is Optional? How to avoid NullPointerException?

Optional is a container type that represents the presence or absence of a value explicitly. It is used to make nullability more visible in APIs and force callers to think about missing values instead of assuming every reference is non-null.

It helps reduce some NullPointerException risks, but it is not a magic solution. Avoiding NPEs also depends on good API contracts, validation, safe defaults, and careful null handling. In interviews, I usually say Optional is best for return values where absence is meaningful, not for every field or parameter in a class.

109. Default and static methods in interfaces.

Default methods allow interfaces to provide a method implementation, which helps evolve APIs without breaking every existing implementation. Static methods in interfaces belong to the interface itself and are called using the interface name rather than through instances.

This design became especially useful when Java added streams and collection enhancements, because interfaces could gain helpful behavior without forcing immediate code changes across all implementations. In interviews, I explain default methods as backward-compatible interface evolution and static methods as interface-level utilities.

110. What is forEach() vs traditional for loop?

forEach() is a higher-level iteration style often used with collections and streams. It makes code concise when the operation is simple and mostly focused on applying an action to each element. A traditional for loop gives more control over index access, early exits, and complex iteration behavior.

In interviews, I usually say forEach() improves readability for straightforward processing, while traditional loops remain useful when I need indexing, break or continue behavior, or more explicit control over flow and debugging. The strongest answer is about control versus readability, not that one style is always better.

111. Explain method references.

Method references are a shorthand form of lambda expressions used when an existing method already matches the required functional interface signature. Instead of writing a lambda that simply calls another method, you can reference that method directly.

Examples include System.out::println, String::trim, or MyType::new for constructor references. In interviews, I explain them as a readability improvement for lambdas that only forward work to an existing method with a matching shape. They do not add new capability beyond lambdas, but they often make stream pipelines and callback code cleaner and easier to scan.

112. What are new features in Java 17/21 (records, sealed classes, pattern matching)?

Modern Java releases added several language features aimed at clearer modeling and safer code. Records reduce boilerplate for immutable data carriers. Sealed classes restrict which types can extend a base type. Pattern matching improves readability when testing and extracting structured values.

In Java 21, virtual threads are also a major feature for concurrency. In interviews, I focus less on memorizing every release note and more on explaining why these changes matter: less boilerplate, more explicit domain modeling, better exhaustiveness, and simpler scalable concurrency.

113. What is record in Java?

A record is a special Java type introduced for immutable data carriers. It automatically provides constructor, accessors, equals(), hashCode(), and toString() implementations based on its declared components, which reduces a lot of repetitive boilerplate in domain models or DTO-like classes.

Records are best when the primary purpose of the type is to hold data rather than manage complex mutable state. In interviews, I describe records as concise immutable carriers that make intent explicit and reduce the cost of writing small data-centric classes.

114. How do you handle date-time (LocalDateTime, etc.)?

Modern Java date-time handling uses the java.time API introduced in Java 8. Types such as LocalDate, LocalTime, LocalDateTime, Instant, ZoneId, and ZonedDateTime model different time concepts explicitly, which makes code safer than the old Date and Calendar APIs.

In interviews, I explain that the right type depends on the business meaning. Use Instant for timeline points, LocalDate for calendar dates without timezone, and ZonedDateTime when timezone context matters. Choosing the correct abstraction is the real skill, because date-time bugs usually come from picking the wrong model rather than the wrong method call.

115. What is module system (JPMS) in Java 9+?

JPMS, the Java Platform Module System, introduced modularization into the Java platform. It allows developers to define modules, explicitly declare dependencies, and control which packages are exported to other modules.

The main benefits are stronger encapsulation, clearer dependency structure, and the ability to build more tailored runtime images. In interviews, I describe it as a way to move from loose classpath-based dependency discovery toward explicit module boundaries, especially for larger systems and platform-level applications. Even if a project does not fully use modules, understanding JPMS shows awareness of modern Java platform structure.

116. Scenario: Design a thread-safe singleton.

A thread-safe singleton ensures only one instance of a class exists and that all threads see the same correctly initialized object. A common and reliable design in Java is eager initialization with a static final instance, or the initialization-on-demand holder idiom for lazy loading.

If I need lazy initialization with minimal complexity, I prefer the holder idiom or an enum singleton. In interviews, I avoid overly complex double-checked locking unless asked specifically, because the goal is correct initialization, clear code, and guaranteed thread safety.

public final class ConfigManager {
    private ConfigManager() {}

    private static class Holder {
        private static final ConfigManager INSTANCE = new ConfigManager();
    }

    public static ConfigManager getInstance() {
        return Holder.INSTANCE;
    }
}

117. Scenario: Implement a simple producer-consumer using BlockingQueue.

A BlockingQueue is a strong answer because it handles synchronization, waiting, and wake-up logic internally. Producers call put() to insert items, and consumers call take() to retrieve them. If the queue is full, producers wait. If it is empty, consumers wait.

This design is simpler and safer than manually coordinating with wait() and notify(). In interviews, I emphasize that BlockingQueue expresses intent clearly: one component produces work, another consumes it, and the queue provides safe backpressure and coordination. It is also easier to maintain because concurrency policy is delegated to a proven library abstraction.

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

Runnable producer = () -> {
    try {
        queue.put("task-1");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

Runnable consumer = () -> {
    try {
        String task = queue.take();
        System.out.println(task);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

118. Scenario: You need sorted unique elements with fast search — which collection?

The most appropriate answer is usually TreeSet. It stores unique elements and maintains them in sorted order, while operations such as insertion, deletion, and search are typically O(log n). That makes it a good fit when both uniqueness and sorted traversal are required.

If raw lookup speed mattered more than sorting, I would choose HashSet, but once sorted order becomes part of the requirement, TreeSet becomes the more appropriate trade-off. Interviewers usually want to see that you can map requirements directly to collection behavior.

119. How would you debug a high CPU or memory leak in a Java application?

I would start by reproducing or observing the issue with metrics, then separate CPU and memory investigation paths. For high CPU, I would inspect thread dumps, profiler samples, and hot methods. For memory leaks, I would look at heap usage trends, GC logs, and heap dumps to identify retained objects and reference chains.

The strongest interview answer is structured: confirm symptoms, capture evidence, identify whether the problem is code, data growth, or configuration, and then validate the fix in the same environment. It shows debugging discipline instead of tool name memorization only.

120. Explain SOLID principles and how they apply in Java.

SOLID stands for Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These principles help structure object-oriented code so it is easier to maintain, extend, test, and reason about.

In Java, they show up in designs such as small focused classes, extension through interfaces or composition, substitutable implementations, role-specific contracts, and dependence on abstractions rather than concrete classes. In interviews, I avoid abstract slogans and instead connect SOLID to better API boundaries, cleaner testing, and reduced coupling in real codebases.

Design Patterns and Coding Challenges

4 questions

121. What are the most common Design Patterns used in Java?

Design patterns are proven solutions to common software design problems. The most commonly discussed patterns in Java interviews include Singleton (ensuring a single instance), Factory (centralizing object creation), Builder (constructing complex objects step-by-step), and Observer (publish-subscribe mechanism for state changes).

In interviews, it is best to explain patterns not just by their UML diagrams, but by what problem they solve. For example, Builder makes code more readable when creating objects with many optional parameters, while Factory abstracts away the exact implementation class being instantiated.

122. How do you find duplicates in a list using Java 8 Streams?

Using the Streams API, you can find duplicates by grouping elements or by utilizing the Collections.frequency method. Another efficient and common approach is to use a HashSet and filter the stream based on whether Set.add() returns false.

In an interview, using a Set is often preferred because it demonstrates an understanding of both the Streams API and Collection fundamentals. It solves the problem concisely with O(n) time complexity.

List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 5, 5);
Set<Integer> seen = new HashSet<>();

List<Integer> duplicates = numbers.stream()
    .filter(n -> !seen.add(n))
    .collect(Collectors.toList());

System.out.println(duplicates); // [2, 5]

123. How do you reverse a string without using built-in methods?

To reverse a string without using methods like StringBuilder.reverse(), you can convert the string to a character array and iterate through it backwards, appending each character to a new StringBuilder or swapping characters in place.

The in-place array swap is the most efficient approach because it operates in O(n/2) time and avoids creating unnecessary intermediate string objects. In interviews, explaining the space and time complexity trade-offs between appending and swapping is just as important as writing the code.

public String reverse(String str) {
    if (str == null) return null;
    char[] chars = str.toCharArray();
    int left = 0;
    int right = chars.length - 1;
    
    while (left < right) {
        char temp = chars[left];
        chars[left] = chars[right];
        chars[right] = temp;
        left++;
        right--;
    }
    return new String(chars);
}

124. How do you check if a string is a palindrome?

A palindrome is a string that reads the same forwards and backwards. The most efficient way to check this is by using two pointers: one starting at the beginning of the string and one at the end, moving towards the middle and comparing characters.

This approach works in O(n) time and O(1) space. In interviews, it is also important to clarify requirements with the interviewer—such as whether the check should be case-insensitive, or if spaces and punctuation should be ignored.

public boolean isPalindrome(String str) {
    if (str == null) return false;
    int left = 0;
    int right = str.length() - 1;
    
    while (left < right) {
        if (str.charAt(left) != str.charAt(right)) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

Official Java References

Use these references when you want to go deeper into the Java language, collection behavior, concurrency utilities, and the runtime concepts covered across this guide.

Resource	Type	Why It Helps
Java Documentation Hub	Oracle Docs	Strong entry point for official Java language, API, and runtime documentation across the major topics covered in this guide.
Collections Framework Overview	Oracle Docs	Useful for revising collection hierarchy, interfaces, algorithms, and implementation trade-offs that appear in Java interviews.
java.util.concurrent Package	Oracle Docs	Helpful for understanding executors, latches, barriers, blocking queues, and the concurrent collections discussed in interview settings.
Java Language Basics	Oracle Tutorials	Good for refreshing core concepts such as classes, inheritance, exceptions, interfaces, and other fundamentals covered in the basic sections.

Related Interview Guides

Continue with focused guides that deepen Java collections knowledge and broaden the surrounding backend interview preparation path.

All Interview Questions

Open interview hub

Java Collections Questions

Open Java Collections guide

coders.sh *

Java Interview Questions and Answers by Topic

Most Asked Java Interview Questions and Answers

Core Java and OOP Basics

1. What are the main features of Java? Explain "Write Once, Run Anywhere."

2. What is the difference between JDK, JRE, and JVM?

3. What is a platform-independent language? How does Java achieve it?

4. Explain the four pillars of OOP: Abstraction, Encapsulation, Inheritance, and Polymorphism.

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

6. What are access modifiers in Java? Explain their scope.

7. What is the difference between abstract class and interface?

8. Can a class extend multiple classes? What about implementing interfaces?

9. What is method overloading vs method overriding?

10. Explain final, finally, and finalize().

11. What is the difference between this and super?

12. What are constructors? Can a constructor be private?

13. What is static keyword? Explain static variables, methods, and blocks.

14. What is the default value of instance variables in Java?

15. Explain the Java Memory Model (Stack vs Heap).

16. What are wrapper classes? Why do we need them?

17. What is autoboxing and unboxing?

18. What is the Object class? Name important methods.

19. What is the difference between String, StringBuilder, and StringBuffer?

20. Why is String immutable in Java? What are its advantages?

Strings, Arrays, Exceptions and IO

21. How does the String pool work in Java?

22. Why is char[] preferred over String for passwords?

23. What happens when you do String s = "hello" + "world"; in a loop?

24. What is the difference between Array and ArrayList?

25. How do you create an immutable class in Java?

26. What are checked and unchecked exceptions?

27. What is the difference between throw and throws?

28. Explain the exception hierarchy in Java.

29. What is try-with-resources? When was it introduced?

30. Can a finally block execute if there is a return in try?

31. What is System.exit() effect on finally?

32. How does Java handle multiple exceptions in one catch block (multi-catch)?

33. What is serialization? How do you make a class serializable?

34. What is transient keyword?

35. What is reflection in Java? When is it used?

36. What are the major IO classes in Java? (File, InputStream, etc.)

37. What is the difference between Reader/Writer and InputStream/OutputStream?

38. How do you read a file line by line efficiently?

39. What is Enum in Java? Can it implement interfaces?

40. Explain varargs (...) and its limitations.

Collections Framework

41. What is the Java Collections Framework? Name root interfaces.

42. Difference between List, Set, and Map.

43. ArrayList vs LinkedList — when to use which?

44. HashMap vs Hashtable vs ConcurrentHashMap.

45. Internal working of HashMap (buckets, hashing, tree bins).

46. What is load factor and rehashing in HashMap?

47. HashSet vs LinkedHashSet vs TreeSet.

48. HashMap vs TreeMap vs LinkedHashMap.

49. How does equals() and hashCode() affect collections?

50. What is fail-fast vs fail-safe iterator?

51. How to make a collection thread-safe?

52. What is CopyOnWriteArrayList?

53. How to sort a List? Comparable vs Comparator.

54. What is PriorityQueue?

55. How to remove duplicates from an ArrayList while preserving order?

56. Explain WeakHashMap.

57. What is IdentityHashMap?

58. How does LinkedHashMap maintain order?

59. What collection for LRU cache implementation?

60. Difference between ArrayDeque and Stack.

61. What are concurrent collections in java.util.concurrent?

62. How to create an immutable collection?

63. What is the time complexity of common operations in major collections?

64. How does TreeMap maintain sorting?

65. Scenario: Store unique elements with fast lookup — which collection?

Multithreading and Concurrency

66. What is a thread? How to create one in Java?

67. Runnable vs Callable vs Thread.

68. What is the difference between start() and run()?

69. What is synchronization? Explain synchronized keyword.

70. What is volatile? When to use it?

71. What is a deadlock? How to avoid it?

72. Explain wait(), notify(), and notifyAll().

73. What is ExecutorService? Name thread pool types.