Top 60 Java Interview Questions and Answers (2025)

Java has been a titan in the software development world for decades, and it’s not going anywhere. From massive enterprise systems to Android apps and backend microservices, its footprint is undeniable. That’s why walking into a Java interview unprepared is like trying to build a house without a blueprint. Interviewers today want to see a deep, practical understanding of the language’s core principles.

From my experience, success in these interviews isn’t about memorizing obscure syntax; it’s about explaining fundamental concepts clearly and confidently. This guide is your blueprint. We’ve compiled 60 of the most critical Java interview questions, covering everything from core OOP principles and the Collections Framework to modern Java 8+ features. Whether you’re a recent graduate or a seasoned developer, this list will help you sharpen your skills and land that job.

---

Core Java & OOP Fundamentals

This is the bedrock of your Java knowledge. Expect these questions in every interview.

1. What are the four main principles of Object-Oriented Programming (OOP)?

OOP is based on four key principles:

• Encapsulation: Binding data (variables) and the code that manipulates it (methods) together into a single unit (an object). It hides the internal state of an object from the outside, which is known as data hiding.
• Abstraction: Hiding complex implementation details and showing only the essential features of the object. Think of it as a car’s dashboard; you see the speedometer, not the complex sensors and wiring behind it.
• Inheritance: The mechanism by which one class (a child or subclass) can inherit the fields and methods of another class (a parent or superclass). This promotes code reuse.
• Polymorphism: The ability of an object to take on many forms. The most common use is when a parent class reference is used to refer to a child class object. This allows a single action to be performed in different ways (e.g., through method overriding).

2. Explain the difference between JDK, JRE, and JVM.

• JVM (Java Virtual Machine): An abstract machine that provides the runtime environment in which Java bytecode can be executed. It’s platform-dependent, which is why you have different JVMs for Windows, macOS, and Linux.
• JRE (Java Runtime Environment): The JRE is the implementation of the JVM. It includes the JVM and the Java class libraries needed to run Java applications.
• JDK (Java Development Kit): The JDK is the full-featured SDK for Java. It contains everything in the JRE, plus development tools like the compiler (javac) and debugger (jdb). You need the JDK to develop Java applications.

3. What is the main method in Java? Why is it public static void?

The main method is the entry point for any Java application.

• public: So it can be accessed by the JVM to start the program.
• static: So the JVM can invoke it without having to create an instance of the main class.
• void: Because it doesn’t return any value to the JVM.

4. What’s the difference between an interface and an abstract class?

Feature	Abstract Class	Interface
Methods	Can have both abstract and concrete (implemented) methods.	Can only have abstract methods before Java 8. Since Java 8, can have default and static implemented methods.
Variables	Can have final, non-final, static, and non-static variables.	Can only have public static final variables (constants).
Inheritance	A class can extend only one abstract class.	A class can implement multiple interfaces.
Purpose	To provide a base for closely related classes (an “is-a” relationship).	To define a contract or capability that different classes can share (a “has-a” capability).

5. Explain method overloading vs. method overriding.

• Method Overloading (Compile-time Polymorphism): Occurs when two or more methods in the same class have the same name but different parameters (different number, type, or order of parameters).
• Method Overriding (Run-time Polymorphism): Occurs when a subclass provides a specific implementation for a method that is already defined in its parent class. The method signature (name and parameters) must be identical.

6. What are constructors in Java? Can a constructor be private?

A constructor is a special method used to initialize an object. It’s called when an instance of the class is created. Yes, a constructor can be private. This is often used to implement the Singleton pattern, where you want to ensure that only one instance of a class can be created.

7. What are the final, finally, and finalize keywords?

• final: A modifier that can be applied to a variable (to make it a constant), a method (to prevent overriding), or a class (to prevent inheritance).
• finally: A block used in a try-catch statement. The finally block always executes, regardless of whether an exception was thrown or caught. It’s used for cleanup code (e.g., closing a file or database connection).
• finalize: A method that the Garbage Collector calls just before destroying an object. Its use is highly discouraged and it has been deprecated since Java 9.

8. Explain the static keyword. Where can it be used?

The static keyword indicates that a member belongs to the class itself, rather than to an instance of the class. It can be used with:

• Variables: A static variable is shared among all instances of the class.
• Methods: A static method can be called without creating an instance of the class.
• Blocks: A static block is executed once when the class is first loaded into memory.
• Nested Classes: A class can be declared static within another class.

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

• ==: An operator that compares object references. It checks if two references point to the exact same object in memory.
• .equals(): A method that compares the content or state of two objects. For the String class, it compares the actual sequence of characters. By default (in the Object class), it behaves the same as ==, but it’s often overridden in classes to provide a meaningful content comparison.

10. Why are String objects immutable in Java?

Immutability means that once a String object is created, its state cannot be changed. This provides several benefits:

• Thread Safety: Immutable objects can be shared freely among multiple threads without risk of corruption.
• Security: System parameters (like database usernames and passwords) are often passed as strings. Immutability prevents them from being altered.
• Caching: Because strings are immutable, their hash codes can be cached. This makes them fast keys for HashMaps.

11. What’s the difference between String, StringBuilder, and StringBuffer?

• String: Immutable. Every modification creates a new String object, which can be inefficient.
• StringBuilder: Mutable. It provides an API to modify the string’s content without creating new objects. It’s not thread-safe, making it the fastest option for single-threaded environments.
• StringBuffer: Mutable and thread-safe. Its methods are synchronized. This makes it slower than StringBuilder and suitable for multi-threaded environments.

12. Explain Java’s access modifiers.

• public: Accessible from anywhere.
• protected: Accessible within the same package and by subclasses in other packages.
• default (no keyword): Accessible only within the same package.
• private: Accessible only within the same class.

13. What is the super keyword used for?

The super keyword is a reference to the parent class object. It’s used to:

1. Call a parent class’s constructor from a child class’s constructor (must be the first statement).
2. Call a parent class’s method that has been overridden in the child class.

14. What are Wrapper classes in Java?

Wrapper classes provide a way to use primitive data types (int, char, boolean, etc.) as objects. For every primitive type, there is a corresponding wrapper class (e.g., int -> Integer, char -> Character). They are essential for use in the Collections Framework, which can only store objects.

15. Explain autoboxing and unboxing.

• Autoboxing: The automatic conversion that the Java compiler makes between a primitive type and its corresponding wrapper class. For example, Integer i = 10;.
• Unboxing: The reverse of autoboxing. It’s the automatic conversion from a wrapper class to its primitive type. For example, int n = i;.

---

The Java Collections Framework

Questions about collections are guaranteed. Know how they work and when to use each one.

16. What is the root interface of the Java Collections Framework?

The root interface is Collection. However, the Map interface is also considered part of the framework but does not extend Collection.

17. What is the difference between List, Set, and Map?

• List: An ordered collection that allows duplicate elements. You can access elements by their integer index. (Examples: ArrayList, LinkedList).
• Set: An unordered collection that does not allow duplicate elements. (Examples: HashSet, TreeSet).
• Map: A collection of key-value pairs. Keys must be unique. It’s used for looking up a value by its associated key. (Examples: HashMap, TreeMap).

18. Explain the difference between ArrayList and LinkedList.

• ArrayList: Backed by a dynamic array. It provides fast random access (getting an element by index) but is slow for additions and removals in the middle of the list, as it may require shifting elements.
• LinkedList: Backed by a doubly-linked list. It’s fast for additions and removals but slow for random access, as it requires traversing the list from the beginning or end.

19. How does a HashMap work internally?

A HashMap stores key-value pairs in an array of “buckets.” When you put(key, value), it calculates the hashCode() of the key and uses it to determine the bucket (index) where the entry should be stored. If multiple keys map to the same bucket (a “collision”), the entries are stored in a linked list (or a balanced tree, since Java 8, for performance).

20. What is the difference between HashMap and Hashtable?

Hashtable is essentially an obsolete, thread-safe version of HashMap.

• HashMap: Not synchronized (not thread-safe). It’s faster. It allows one null key and multiple null values.
• Hashtable: Synchronized (thread-safe). It’s slower. It does not allow any null keys or values. ConcurrentHashMap is the modern replacement for Hashtable.

21. What’s the difference between HashSet and TreeSet?

• HashSet: Stores elements in a HashMap internally. It does not maintain any order. It offers constant-time performance for basic operations.
• TreeSet: Stores elements in a sorted order (either natural order or specified by a Comparator). It is backed by a TreeMap (a self-balancing binary search tree).

22. What is an Iterator? How is it different from a for-each loop?

An Iterator is an object used to traverse a collection. It allows you to safely remove elements from the collection while iterating. A for-each loop provides a simpler syntax for iteration but doesn’t allow for removal. Under the hood, the for-each loop uses an Iterator.

23. Explain the Comparable and Comparator interfaces.

Both are used for sorting objects.

• Comparable: Provides a “natural” sorting order for a class. The class itself must implement this interface and its compareTo() method.
• Comparator: Provides a custom or external sorting order. You create a separate class that implements this interface and its compare() method. This is useful when you can’t modify the class you want to sort, or if you need multiple different sorting strategies.

24. What is the difference between fail-fast and fail-safe iterators?

• fail-fast: Immediately throws a ConcurrentModificationException if the underlying collection is modified structurally (e.g., adding or removing elements) by a means other than the iterator’s own remove() method. Most non-concurrent collections (like ArrayList, HashMap) use fail-fast iterators.
• fail-safe: Does not throw an exception if the collection is modified. They operate on a clone of the collection, so they don’t see modifications made after the iterator was created. Used by classes in java.util.concurrent.

25. What is ConcurrentHashMap and why is it useful?

ConcurrentHashMap is the modern, thread-safe equivalent of Hashtable. It offers much better performance in multi-threaded environments because it uses a technique called “lock striping.” Instead of locking the entire map for every modification, it only locks the specific bucket (or “segment”) being modified, allowing multiple threads to access different parts of the map concurrently.

---

Exception Handling

26. What is the hierarchy of exception classes in Java?

The root class is Throwable. It has two main subclasses:

• Error: Represents serious problems that a reasonable application should not try to catch (e.g., OutOfMemoryError).
• Exception: Represents conditions that a reasonable application might want to catch. It has a major subclass:
  • RuntimeException: Exceptions that can be prevented programmatically (e.g., NullPointerException, ArrayIndexOutOfBoundsException).

27. What’s the difference between checked and unchecked exceptions?

• Checked Exceptions: These are exceptions that the compiler forces you to handle, either by catching them in a try-catch block or by declaring them with the throws keyword. They are subclasses of Exception (but not RuntimeException). They represent predictable but unpreventable problems (e.g., IOException, SQLException).
• Unchecked Exceptions: These are exceptions that the compiler does not require you to handle. They are subclasses of RuntimeException and Error. They usually indicate programming errors.

28. What is the purpose of the try-with-resources statement?

Introduced in Java 7, it simplifies the process of closing resources. Any resource that implements the AutoCloseable interface can be declared in the try statement. The resource will be automatically closed at the end of the block, whether it completes normally or with an exception, eliminating the need for a finally block for cleanup.

29. What is the throw keyword vs. the throws keyword?

• throw: Used to manually throw an exception within a method.
• throws: Used in a method signature to declare the types of checked exceptions that the method might throw. It informs the caller that they must handle these exceptions.

30. Can a finally block execute without a catch block?

Yes. A try block can be followed by a finally block without any catch blocks. The finally block will still execute after the try block completes.

---

Multithreading and Concurrency

31. How can you create a thread in Java?

There are two main ways:

1. Extend the Thread class: Create a new class that extends Thread and override its run() method.
2. Implement the Runnable interface: Create a class that implements Runnable and its run() method. Then, create a Thread object, passing an instance of your Runnable class to its constructor. Implementing Runnable is preferred because it allows your class to extend another class.

32. What is the difference between .start() and .run() methods of a Thread?

• .start(): Creates a new thread and makes it eligible to be run by the thread scheduler. The new thread will then execute the code inside the run() method.
• .run(): Simply executes the code in the run() method within the current thread. It does not start a new thread.

33. Explain the thread lifecycle in Java.

A thread goes through several states:

1. NEW: The thread has been created but not yet started.
2. RUNNABLE: The thread is ready to be executed by the scheduler.
3. BLOCKED: The thread is waiting to acquire a monitor lock.
4. WAITING: The thread is waiting indefinitely for another thread to perform a particular action (e.g., calling notify()).
5. TIMED_WAITING: The thread is waiting for a specified amount of time.
6. TERMINATED: The thread has completed its execution.

34. What does the synchronized keyword do?

synchronized is used to control access to shared resources by multiple threads. It can be applied to a method or a block of code. When a thread enters a synchronized block, it acquires a “monitor lock” on the object. No other thread can enter a synchronized block on the same object until the first thread exits and releases the lock.

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

• Process: An instance of a program running. Each process has its own private memory space.
• Thread: A “lightweight process.” It’s the smallest unit of execution within a process. Multiple threads within the same process share the same memory space.

36. What is a deadlock? How can you prevent it?

A deadlock is a situation where two or more threads are blocked forever, each waiting for a resource held by the other. You can prevent deadlocks by:

• Avoiding nested locks: Try not to acquire multiple locks at once.
• Lock ordering: Always acquire locks in the same, consistent order across all threads.
• Using timeouts: Use lock acquisitions that time out, so a thread doesn’t wait indefinitely.

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

These methods of the Object class are used for inter-thread communication. They must be called from within a synchronized block.

• wait(): Causes the current thread to release the lock and wait until another thread invokes notify() or notifyAll() on the same object.
• notify(): Wakes up a single thread that is waiting on this object’s monitor.
• notifyAll(): Wakes up all threads that are waiting on this object’s monitor.

38. What is a volatile variable?

The volatile keyword ensures that changes to a variable are always visible to other threads. It prevents compiler optimizations like caching the variable’s value in a CPU register, forcing all reads and writes to go directly to main memory. It guarantees visibility but not atomicity.

39. What is the Java Memory Model?

The Java Memory Model (JMM) defines the rules for how threads interact through memory. It specifies when changes to variables made by one thread become visible to others. Keywords like volatile, synchronized, and final are defined by the JMM.

40. Explain the Executor Framework.

The Executor Framework, part of java.util.concurrent, provides a high-level API for managing threads. Instead of creating threads manually, you submit Runnable or Callable tasks to an ExecutorService (a thread pool). This improves performance by reusing threads and provides better control over thread management.

---

Java 8+ Features

These features changed modern Java development. You must know them.

41. What is a Lambda Expression?

A lambda expression is a short block of code that takes in parameters and returns a value. They are essentially anonymous functions. They allow you to treat functionality as a method argument, or code as data.

42. What is a Functional Interface?

A functional interface is an interface that contains exactly one abstract method. The @FunctionalInterface annotation is used to enforce this. They are the target types for lambda expressions and method references.

43. Explain the Java Stream API.

The Stream API is used to process sequences of elements from a source (like a Collection). Streams support functional-style operations on elements, such as map-filter-reduce. They allow for efficient, declarative processing of data.

44. What are intermediate and terminal operations in a Stream?

• Intermediate Operations: These operations return a new stream and are lazy (they don’t execute until a terminal operation is invoked). Examples include filter(), map(), and sorted().
• Terminal Operations: These operations produce a result or a side-effect. They trigger the execution of the entire stream pipeline. Examples include forEach(), collect(), and reduce().

45. What is the Optional class? What problem does it solve?

Optional is a container object which may or may not contain a non-null value. It was introduced to solve the problem of NullPointerExceptions by providing a type-safe way to represent an optional value instead of returning null.

46. What are default methods in interfaces?

Default methods, introduced in Java 8, are methods in an interface that have an implementation. A class that implements the interface can use the default implementation or override it. This feature was added to allow for the evolution of interfaces (like adding new methods to Collection) without breaking existing implementing classes.

47. Explain the forEach method added in Java 8.

The forEach method provides a simple way to iterate over the elements of a collection or stream and perform a given action. It takes a lambda expression as an argument.

48. What is the difference between map and flatMap in Streams?

• map: Transforms each element of a stream into another object, resulting in a new stream of the same size. (e.g., Stream<String> -> Stream<Integer>).
• flatMap: Transforms each element into a stream of other objects, and then “flattens” all the resulting streams into a single, new stream. It’s used when each element can map to zero, one, or multiple elements in the output.

---

Advanced & Miscellaneous Topics

49. What is Garbage Collection? Can you force it?

Garbage Collection (GC) is the process by which the JVM automatically reclaims memory occupied by objects that are no longer referenced. You cannot force garbage collection. You can suggest it by calling System.gc(), but there is no guarantee that the JVM will run it.

50. What is serialization?

Serialization is the process of converting an object’s state into a byte stream, which can then be saved to a file or sent over a network. The reverse process is deserialization. A class must implement the Serializable marker interface to be serializable.

51. What does the transient keyword do?

The transient keyword is used to mark a field in a class to indicate that it should not be serialized when the object is converted to a byte stream.

52. Explain Reflection in Java.

Reflection is an API that allows you to inspect and manipulate classes, interfaces, fields, and methods at runtime, without knowing their names at compile time. It’s powerful but should be used with caution as it can be slow and break encapsulation.

53. What are Java Generics?

Generics provide compile-time type safety by allowing you to create classes, interfaces, and methods that operate on types as parameters. They eliminate the need for casting and prevent ClassCastExceptions.

54. What is type erasure?

During compilation, the Java compiler uses generic type information to ensure type safety but then erases it. The resulting bytecode contains only ordinary classes and methods, ensuring backward compatibility with older JVMs that don’t understand generics.

55. What is an enum in Java?

An enum is a special data type that enables for a variable to be a set of predefined constants. Enums are type-safe and have their own namespace.

56. Explain the contract between hashCode() and equals().

The contract is crucial for collections like HashMap:

1. If two objects are equal according to the equals() method, then they must have the same hash code.
2. If two objects have the same hash code, they are not necessarily equal. (This is a collision).
3. If you override one, you must override the other.

57. What are JAR, WAR, and EAR files?

• JAR (Java Archive): A package file format used to bundle multiple Java class files, associated metadata, and resources into one file for distribution.
• WAR (Web Application Archive): Used to package a web application. It’s a JAR file with a specific directory structure, containing servlets, JSPs, HTML, and other resources.
• EAR (Enterprise Application Archive): Used to package an enterprise application. It can contain multiple JARs and WARs.

58. What is ClassLoader in Java?

A ClassLoader is part of the JRE that is responsible for dynamically loading Java classes into the JVM. The three main class loaders are the Bootstrap, Extension, and Application ClassLoaders.

59. What are Records, introduced in Java 14?

Records are a concise way to declare classes that are intended to be simple, immutable data carriers. The compiler automatically generates the constructor, fields, equals(), hashCode(), and toString() methods for you.

60. Describe a complex technical problem you solved using Java.

This is your moment to tell a story. A great answer has a clear structure:

• Situation: Describe the project and the business goal. (“We were building a high-traffic e-commerce site…”)
• Problem: Explain the specific technical challenge. (“…and our initial approach to caching product data was causing stale data to be served to users and was not thread-safe, leading to inconsistent results under load.”)
• Action: Detail the steps you took and the Java concepts you applied. (“I designed and implemented a new caching layer using ConcurrentHashMap for thread safety. I also used a ScheduledExecutorService to periodically evict stale entries and refresh them from the database asynchronously, preventing performance hits on user-facing threads.”)
• Result: State the positive outcome. (“This new caching mechanism eliminated data consistency issues and improved page load times by 40% under peak load.”)

Conclusion

Getting through these 60 questions is a huge accomplishment, but the journey doesn’t end here. The best way to truly master Java is to write code every day. Build a project, contribute to an open-source library, and explore new features as they are released. The confidence you gain from hands-on experience is what will truly set you apart in any interview. Good luck!