Java Interview Questions and Answers 2026: The Complete Guide for Freshers and Experienced Developers

If you are preparing for a placement drive or a lateral role, mastering the most common java interview questions is the single most reliable way to walk into the room with confidence. Java has powered enterprise systems for close to three decades, and it remains the default language for campus hiring at service companies like TCS, Infosys, Wipro, and Cognizant, as well as for backend roles at product firms and startups across India. This guide collects more than 45 frequently asked questions, grouped by topic, with concise and technically correct answers, code examples, and comparison tables. Whether you are a fresher facing your first coding round or an experienced engineer targeting a senior backend position, you will find questions here that map directly to what interviewers actually ask.

We have deliberately gone deeper on the areas that most cheat sheets skip: exception handling, multithreading and concurrency utilities, JVM memory internals, and the Java 8+ functional features that now show up in almost every interview. Read straight through, or jump to the section you are weakest on.

Table of Contents

1. Core Java Basics
2. OOP Concepts
3. Collections Framework
4. Exception Handling
5. Multithreading and Concurrency
6. JVM and Memory Management
7. String Handling
8. Java 8+ Features, Streams and Lambdas
9. Coding and Output Questions
10. How to Prepare for a Java Interview
11. FAQ

Core Java Basics

These are the warm-up questions in almost every interview. Getting them crisp signals that your fundamentals are solid.

1. Why is Java called platform independent?

Java source code is compiled into an intermediate form called bytecode (a .class file) rather than into native machine code. This bytecode is not tied to any operating system or processor. Any machine that has a Java Virtual Machine (JVM) can run it. The JVM itself is platform dependent, but your program is not. This is the meaning of the famous phrase "write once, run anywhere."

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

This is one of the most common java interview questions for freshers, and interviewers expect you to distinguish all three clearly.

Component	Full form	Contains	Purpose
JVM	Java Virtual Machine	Class loader, bytecode verifier, execution engine	Runs bytecode; the abstract machine that executes Java
JRE	Java Runtime Environment	JVM + core libraries (rt.jar)	Everything needed to run a Java program
JDK	Java Development Kit	JRE + compiler (javac), debugger, tools	Everything needed to develop and run Java

A simple way to remember it: JDK is for developers, JRE is for running programs, and the JVM is the engine inside both.

3. What is bytecode?

Bytecode is the compiled, platform-neutral instruction set produced by the Java compiler (javac). It is stored in .class files and is interpreted or just-in-time compiled by the JVM at runtime.

4. What is the JIT compiler?

The Just-In-Time (JIT) compiler is part of the JVM. Instead of interpreting bytecode line by line every time, the JIT compiles frequently executed bytecode ("hot" code) into native machine code at runtime and caches it. This dramatically improves performance for long-running applications.

5. What are the primitive data types in Java?

Java has eight primitive types: byte, short, int, long, float, double, char, and boolean. They are not objects and are stored directly on the stack (as local variables), which makes them fast and memory efficient.

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

The == operator compares references (whether two variables point to the same object in memory) for objects, and compares actual values for primitives. The equals() method compares content, based on how it is overridden. For example, String overrides equals() to compare characters.

String a = new String("hello");
String b = new String("hello");
System.out.println(a == b);      // false, different objects
System.out.println(a.equals(b)); // true, same content

7. What is autoboxing and unboxing?

Autoboxing is the automatic conversion of a primitive into its wrapper class object (int to Integer). Unboxing is the reverse. It lets you use primitives and wrapper objects interchangeably in many contexts.

Integer boxed = 10;   // autoboxing: int -> Integer
int unboxed = boxed;  // unboxing: Integer -> int

8. What is the difference between path and classpath?

PATH is an operating system environment variable that tells the OS where to find executables like java and javac. CLASSPATH is a Java-specific variable that tells the JVM and compiler where to find user-defined classes and packages.

9. Is Java pass-by-value or pass-by-reference?

Java is always pass-by-value. For objects, the value being passed is a copy of the reference, not the object itself. So you can mutate the object the reference points to, but reassigning the parameter inside the method does not affect the caller's variable.

OOP Concepts

Object-oriented programming is the conceptual heart of Java. Expect several of these in every round.

10. What are the four pillars of OOP?

Encapsulation, Inheritance, Polymorphism, and Abstraction.

• Encapsulation: bundling data and methods together and restricting direct access using access modifiers (private fields with public getters and setters).
• Inheritance: a class acquires properties and behavior from a parent class using extends.
• Polymorphism: the same interface behaves differently based on the object, achieved through overloading and overriding.
• Abstraction: hiding implementation detail and exposing only essential features, using abstract classes and interfaces.

11. What is the difference between method overloading and overriding?

Overloading means multiple methods with the same name but different parameter lists in the same class; it is resolved at compile time (static polymorphism). Overriding means a subclass provides a new implementation of a method already defined in its parent; it is resolved at runtime (dynamic polymorphism).

class Calculator {
    int add(int a, int b) { return a + b; }          // overloaded
    double add(double a, double b) { return a + b; } // overloaded
}

class Base { void show() { System.out.println("Base"); } }
class Child extends Base {
    @Override void show() { System.out.println("Child"); } // overridden
}

12. What is the difference between an abstract class and an interface?

Feature	Abstract class	Interface
Methods	Abstract and concrete	Abstract, plus default and static (Java 8+), private (Java 9+)
Variables	Any type	public static final only
Multiple inheritance	Not supported	Supported
Constructor	Yes	No
Use when	Classes share state and behavior	You want to define a contract

Since Java 8, interfaces can have default and static methods, which narrowed the gap. Use an interface for "can do" capabilities and an abstract class for "is a" relationships with shared state.

13. Does Java support multiple inheritance?

Java does not support multiple inheritance through classes, to avoid the diamond problem (ambiguity when two parent classes have the same method). It does support multiple inheritance of type through interfaces, since a class can implement many interfaces.

14. What is the difference between composition and inheritance?

Inheritance models an "is-a" relationship (a Car is a Vehicle). Composition models a "has-a" relationship (a Car has an Engine). Composition is generally preferred because it is more flexible and avoids tight coupling. This "favor composition over inheritance" principle is a favorite among experienced-level interviewers.

15. What is the difference between static and instance methods?

A static method belongs to the class and can be called without creating an object; it cannot access instance variables directly. An instance method belongs to an object and can access both instance and static members.

16. Can we override a static method?

No. Static methods are resolved at compile time based on the reference type, not the object. If you declare a static method with the same signature in a subclass, it is called method hiding, not overriding.

17. What is a marker interface?

A marker interface is an empty interface with no methods, used to signal metadata to the JVM or frameworks. Examples are Serializable and Cloneable. Modern code often uses annotations for the same purpose.

Collections Framework

The Collections Framework is heavily tested because real-world Java is full of lists, maps, and sets. Interviewers love to probe the differences between implementations.

18. What is the difference between ArrayList and LinkedList?

Aspect	ArrayList	LinkedList
Internal structure	Dynamic array	Doubly linked list
Random access (get)	O(1)	O(n)
Insert/delete in middle	O(n), shifting needed	O(1) once positioned
Memory	Less overhead	Extra memory for node pointers
Best for	Frequent reads	Frequent insertions and deletions

For most read-heavy use cases, ArrayList wins. Use LinkedList only when you insert and remove from the ends or middle very often.

19. What is the difference between HashMap and Hashtable?

HashMap is not synchronized, allows one null key and multiple null values, and is faster. Hashtable is synchronized (thread safe), allows no null keys or values, and is largely legacy. For thread-safe maps today, prefer ConcurrentHashMap.

20. How does HashMap work internally?

A HashMap stores entries in an array of buckets. When you put a key, it computes the key's hashCode(), applies an internal hashing function, and derives a bucket index. Multiple keys mapping to the same bucket form a linked list, and since Java 8, a bucket converts to a balanced tree (red-black tree) once it exceeds a threshold (8 entries), improving worst-case lookups from O(n) to O(log n). Retrieval uses equals() to find the exact key within a bucket.

21. What is the difference between HashSet and TreeSet?

HashSet is backed by a HashMap, offers O(1) average operations, and does not maintain order. TreeSet is backed by a red-black tree, keeps elements sorted, and offers O(log n) operations. Use TreeSet only when you need sorted iteration.

22. What is the difference between Iterator and ListIterator?

Iterator traverses in one direction (forward) and works on any Collection. ListIterator works only on Lists, traverses both forward and backward, and can add or replace elements during iteration.

23. What is fail-fast versus fail-safe?

A fail-fast iterator throws ConcurrentModificationException if the collection is structurally modified during iteration (for example, iterating an ArrayList while removing from it). A fail-safe iterator works on a clone or snapshot and does not throw, as in ConcurrentHashMap and CopyOnWriteArrayList.

24. What is the difference between Comparable and Comparator?

Comparable defines a single natural ordering via compareTo(), implemented inside the class itself. Comparator is an external strategy via compare(), letting you define multiple orderings without modifying the class.

List<String> names = new ArrayList<>(List.of("Ravi", "Aarti", "Karan"));
Collections.sort(names);                          // natural (Comparable)
names.sort(Comparator.comparing(String::length)); // custom (Comparator)

Exception Handling

Reference cheat sheets often skim over exceptions, but Indian placement interviews dig into the final, finally, finalize trio and the checked-versus-unchecked distinction.

25. What is the difference between checked and unchecked exceptions?

Type	Checked	Unchecked
Checked at	Compile time	Runtime
Parent	Exception (not RuntimeException)	RuntimeException
Must handle	Yes, or declare with throws	No
Examples	IOException, SQLException	NullPointerException, ArithmeticException

Checked exceptions represent recoverable conditions the compiler forces you to handle. Unchecked exceptions usually indicate programming errors.

26. What is the difference between final, finally and finalize?

• final is a keyword used to make a variable constant, prevent method overriding, or prevent inheritance.
• finally is a block that always executes after try-catch, used for cleanup like closing resources.
• finalize() was a method called by the garbage collector before reclaiming an object. It is deprecated from Java 9 onward, so avoid relying on it.

27. What is the difference between throw and throws?

throw is used to explicitly throw a single exception instance from within a method. throws is used in a method signature to declare that the method may throw one or more exceptions, delegating handling to the caller.

void readFile(String path) throws IOException {
    if (path == null) throw new IllegalArgumentException("path is null");
    // ... may throw IOException
}

28. What is a try-with-resources statement?

Introduced in Java 7, try-with-resources automatically closes any resource that implements AutoCloseable at the end of the block, eliminating manual finally cleanup and preventing resource leaks.

try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    return br.readLine();
} // br is closed automatically, even if an exception occurs

29. Can a finally block override the value returned by a try block?

Yes, if the finally block contains a return statement it overrides the try or catch return value, which is considered bad practice because it can silently swallow exceptions. Avoid returning from finally.

30. What is exception chaining?

Exception chaining wraps a lower-level exception inside a higher-level one, preserving the original cause. You pass the cause to the constructor, and it is retrievable via getCause(). This keeps the full context for debugging.

Multithreading and Concurrency

Concurrency is where mid-level and senior interviews separate strong candidates. The concurrency utilities below are exactly the topics most guides omit.

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

A process is an independent program with its own memory space. A thread is a lightweight unit of execution within a process; threads of the same process share memory (heap) but have their own stack. Threads are cheaper to create and switch than processes.

32. What are the ways to create a thread in Java?

There are two classic ways: extend the Thread class and override run(), or implement the Runnable interface and pass it to a Thread. Implementing Runnable is preferred because it leaves your class free to extend something else. Modern code often uses ExecutorService or, for return values, Callable with Future.

Runnable task = () -> System.out.println("Running in " + Thread.currentThread().getName());
new Thread(task).start();

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

Calling start() creates a new thread and then invokes run() on that new thread. Calling run() directly just executes the code on the current thread, with no concurrency. This is a classic trick question.

34. What is synchronization and why is it needed?

Synchronization controls access to shared resources so that only one thread can execute a critical section at a time, preventing race conditions and data corruption. It is achieved with the synchronized keyword on methods or blocks, or with explicit locks.

class Counter {
    private int count = 0;
    public synchronized void increment() { count++; } // atomic per thread
    public int get() { return count; }
}

35. What is the difference between wait() and sleep()?

wait() is called on an object, releases the lock the thread holds, and waits until notified via notify() or notifyAll(). sleep() is a static Thread method, pauses the current thread for a set time, and does not release any lock. wait() is used for inter-thread coordination, sleep() for timed delays.

36. What is a deadlock?

A deadlock occurs when two or more threads are each waiting for a lock the other holds, so none can proceed. You avoid it by acquiring locks in a consistent global order, using timeouts with tryLock(), or minimizing lock scope.

37. What is the volatile keyword?

volatile ensures that reads and writes to a variable go directly to main memory, so all threads see the latest value. It guarantees visibility but not atomicity, so it is suitable for flags but not for compound operations like incrementing.

38. What is ExecutorService?

ExecutorService is a higher-level thread management API from java.util.concurrent. Instead of manually creating threads, you submit tasks to a managed thread pool, which reuses threads and handles scheduling. This is the recommended way to run concurrent tasks in production.

ExecutorService pool = Executors.newFixedThreadPool(4);
Future<Integer> result = pool.submit(() -> 2 + 2);
System.out.println(result.get()); // 4
pool.shutdown();

39. What is the difference between CountDownLatch and CyclicBarrier?

CountDownLatch lets one or more threads wait until a set of operations in other threads complete; it cannot be reused. CyclicBarrier makes a group of threads wait for each other at a common barrier point and can be reused for multiple cycles.

JVM and Memory Management

Understanding how the JVM manages memory shows depth. These questions come up especially in backend and performance-focused interviews.

40. What are the main memory areas of the JVM?

The key runtime areas are the Heap (objects and their instance variables, shared across threads), the Stack (per-thread, holds method frames and local variables), the Method Area or Metaspace (class metadata, static variables), the Program Counter register (per thread), and native method stacks. The heap is split into Young Generation (Eden and Survivor spaces) and Old Generation.

41. What is garbage collection and how does it work?

Garbage collection is the automatic reclamation of memory occupied by objects that are no longer reachable from any live reference. The JVM identifies unreachable objects and frees them, so you do not manage memory manually. Most collectors use a generational approach: short-lived objects are collected quickly in the Young Generation (minor GC), while long-lived objects are promoted to the Old Generation (major GC).

42. What are strong, weak, soft and phantom references?

• Strong reference: the normal reference; the object is never collected while it is reachable.
• Soft reference: collected only when memory is low; useful for caches.
• Weak reference: collected at the next GC cycle if no strong reference exists; used in WeakHashMap.
• Phantom reference: enqueued after the object is finalized; used for advanced cleanup.

43. What causes a memory leak in Java, if GC is automatic?

Even with garbage collection, memory leaks happen when objects remain reachable but are no longer needed, so GC cannot reclaim them. Common causes are unclosed resources, static collections that keep growing, listeners that are never deregistered, and keys with poor hashCode/equals in maps.

44. What is the difference between stack and heap memory?

Stack memory stores primitives and object references per thread and is freed automatically when a method returns; it is fast and has limited size. Heap memory stores the actual objects, is shared across threads, and is managed by the garbage collector.

String Handling

Strings appear in nearly every Java program and interview. The immutability question is almost guaranteed.

45. Why are strings immutable in Java?

Once created, a String object cannot be changed. Immutability enables the String pool (safe sharing of literals), makes strings safe as HashMap keys and in multithreaded code, and improves security since values like file paths cannot be altered after validation. Any operation that seems to modify a string actually creates a new one.

46. What is the string constant pool?

The string pool is a special area in the heap where string literals are stored. When you create a string with a literal, the JVM checks the pool and reuses the existing object if the value already exists, saving memory.

String a = "Goodspace";       // goes to the pool
String b = "Goodspace";       // reuses the same pooled object
String c = new String("Goodspace"); // new object on the heap
System.out.println(a == b); // true
System.out.println(a == c); // false

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

String is immutable. StringBuilder is mutable and not synchronized, so it is fast and best for single-threaded string building. StringBuffer is mutable and synchronized, so it is thread safe but slower. For loops that concatenate many strings, use StringBuilder to avoid creating many intermediate objects.

48. What does the intern() method do?

intern() returns the canonical representation of a string from the pool. If the pool already contains an equal string, that reference is returned; otherwise the string is added to the pool and its reference returned.

Java 8+ Features, Streams and Lambdas

Modern Java interviews almost always test Java 8 functional features. Both major reference guides underplay this, so study it carefully.

49. What is a lambda expression?

A lambda is a concise way to represent an anonymous function that can be passed around. It implements a functional interface (an interface with a single abstract method) without the boilerplate of an anonymous class.

List<Integer> nums = List.of(3, 1, 2);
nums.stream().sorted().forEach(System.out::println); // 1 2 3

50. What is a functional interface?

A functional interface has exactly one abstract method, so it can be the target of a lambda. Examples from java.util.function include Predicate<T>, Function<T,R>, Consumer<T>, and Supplier<T>. The @FunctionalInterface annotation enforces the single-method rule.

51. What is the Stream API?

The Stream API processes sequences of elements in a declarative, functional style. Streams support intermediate operations (like filter, map, sorted) that are lazy, and terminal operations (like collect, forEach, reduce) that trigger execution. Streams do not modify the source and can run in parallel.

List<String> names = List.of("Ravi", "Aarti", "Karan", "Anil");
List<String> aNames = names.stream()
    .filter(n -> n.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList()); // [AARTI, ANIL]

52. What is the difference between map() and flatMap()?

map() transforms each element into exactly one output element. flatMap() transforms each element into a stream and then flattens all those streams into one, useful for nested collections.

53. What is Optional and why use it?

Optional<T> is a container that may or may not hold a value, introduced to represent the absence of a value explicitly and reduce NullPointerException. Instead of returning null, you return an Optional and callers handle emptiness with orElse, map, or ifPresent.

Optional<String> maybe = Optional.ofNullable(findUser());
String name = maybe.map(String::trim).orElse("Guest");

54. What are default methods in interfaces?

Default methods, added in Java 8, let an interface provide a method body using the default keyword. This allowed the JDK to add methods like forEach to existing interfaces without breaking classes that already implemented them.

55. What is a method reference?

A method reference is shorthand for a lambda that calls an existing method, written with ::. Forms include static (Integer::parseInt), instance (String::toUpperCase), and constructor (ArrayList::new) references.

56. What is the difference between intermediate and terminal stream operations?

Intermediate operations return a new stream and are lazy, meaning they do not run until a terminal operation is invoked. Terminal operations produce a result or side effect and close the stream. A stream can have many intermediate operations but only one terminal operation.

Coding and Output Questions

Placement rounds at TCS, Infosys, and similar service companies almost always include short coding or "predict the output" questions. Practice explaining your reasoning aloud, since interviewers care about your thought process as much as the answer.

57. Reverse a string without using the reverse() method

public static String reverse(String s) {
    char[] chars = s.toCharArray();
    int i = 0, j = chars.length - 1;
    while (i < j) {
        char tmp = chars[i];
        chars[i++] = chars[j];
        chars[j--] = tmp;
    }
    return new String(chars);
}

58. Check whether a string is a palindrome

public static boolean isPalindrome(String s) {
    int i = 0, j = s.length() - 1;
    while (i < j) {
        if (s.charAt(i++) != s.charAt(j--)) return false;
    }
    return true;
}

59. Find the first non-repeating character in a string

public static Character firstUnique(String s) {
    Map<Character, Integer> counts = new LinkedHashMap<>();
    for (char c : s.toCharArray())
        counts.merge(c, 1, Integer::sum);
    for (var e : counts.entrySet())
        if (e.getValue() == 1) return e.getKey();
    return null;
}

60. What is the output of this code?

Integer a = 127, b = 127;
Integer c = 128, d = 128;
System.out.println(a == b); // true
System.out.println(c == d); // false

The output is true then false. Java caches Integer objects in the range -128 to 127 through the Integer cache, so a and b reference the same cached object. Values outside that range create new objects, so c == d compares different references. This is a classic trap that tests both autoboxing and reference equality.

61. What is the output when you modify an object passed to a method?

static void update(StringBuilder sb) { sb.append(" world"); }
public static void main(String[] args) {
    StringBuilder s = new StringBuilder("hello");
    update(s);
    System.out.println(s); // hello world
}

Because Java passes a copy of the reference, the method mutates the same StringBuilder object, so the change is visible to the caller. Had the method reassigned sb to a new object, the caller would see no change, which reinforces that Java is pass-by-value of references.

How to Prepare for a Java Interview

Knowing the answers is only half the battle. A structured preparation plan separates candidates who freeze under pressure from those who perform.

1. Rebuild your fundamentals in order. Start with core Java and OOP, then move to collections, exceptions, multithreading, the JVM, and finally Java 8 streams. Do not jump straight to advanced topics if your basics are shaky, because interviewers probe fundamentals first and use them to gauge whether to go deeper.

2. Write code by hand and on a blank editor. Many placement rounds and screen-share interviews ask you to code without autocomplete. Practice the classic patterns: string manipulation, array traversal, HashMap-based counting, and simple recursion until they are automatic.

3. Learn the "why" behind each answer. Reciting that HashMap is O(1) is weak; explaining bucket hashing, collisions, and the treeification threshold is strong. Interviewers reward depth and follow up on shallow answers, so prepare to be asked "why" two or three times on any topic.

4. Practice explaining out loud under time pressure. Technical knowledge often collapses under interview stress. The most effective fix is realistic rehearsal. A Goodspace AI Mock Interview lets you run a full Java interview simulation, get asked follow-up questions in real time, and receive feedback on both your answers and your communication, which is exactly the muscle campus and lateral rounds test.

5. Tailor to the company type. Service companies like TCS, Infosys, and Wipro emphasize core Java, OOP, output prediction, and basic DSA in early rounds. Product companies and startups push harder on collections internals, concurrency, JVM tuning, and system design. Know which track you are on and weight your prep accordingly.

6. Do a timed dry run before the real thing. Simulate the full experience, including the awkward pauses and the follow-ups you did not expect. Running one more Goodspace AI Mock Interview focused on your weakest section, whether that is multithreading or streams, is often the difference between a hesitant answer and a confident one on interview day.

7. Review your own code and past mistakes. Keep a short log of every question you got wrong or answered weakly, and revisit it the night before. Spaced repetition of your personal weak spots beats re-reading topics you already know.

FAQ

How many Java interview questions should I prepare?

Aim to be genuinely comfortable with at least 50 to 60 questions spanning core Java, OOP, collections, exceptions, multithreading, the JVM, strings, and Java 8 features. Depth matters more than breadth, so it is better to explain 50 questions deeply than to memorize 200 shallowly.

Are Java interviews hard for freshers in India?

For freshers, most service company rounds focus on fundamentals: OOP, core syntax, output questions, and basic collections, which are very learnable with structured practice. The difficulty rises for product roles and lateral hires, where concurrency, JVM internals, and design questions appear.

Should I learn Java 8 features for interviews in 2026?

Yes. Streams, lambdas, functional interfaces, and Optional are now standard interview material, and many codebases assume familiarity with them. Skipping Java 8 is one of the most common preparation gaps, so treat that section as mandatory.

What is the most commonly asked Java interview question?

The differences between JDK, JRE, and JVM, the four pillars of OOP, and why strings are immutable are among the most frequently asked. Overloading versus overriding and how HashMap works internally are close behind.

How do I answer a Java question I do not know?

Stay calm, state what you do know, and reason out loud toward an answer rather than going silent. Interviewers often value a clear thought process and honesty over a memorized response, and admitting a gap while showing how you would find the answer is far better than bluffing.

How can I practice Java interviews realistically?

Beyond solving problems, rehearse in a live, spoken format so you get used to answering under pressure and handling follow-ups. Mock interviews, whether with a peer or an AI-driven simulator, build the confidence and clarity that reading alone cannot.

---

Master these questions, understand the reasoning behind each answer, and rehearse them out loud until they feel natural. Do that, and you will walk into your next Java interview ready for whatever the panel asks. Good luck.