Java Interview Questions for Freshers & Experienced (2026 Master Guide)

Q1. Explain the core principles of Object-Oriented Programming (OOP) in Java.

Foundation • 0-2 Yrs

The 4 pillars are Encapsulation (data hiding via private fields and public getters/setters), Abstraction (hiding implementation details via interfaces and abstract classes), Inheritance (reusability via the 'extends' keyword), and Polymorphism (compile-time method overloading and runtime method overriding via dynamic method dispatch).

Q2. Why is String immutable in Java and what are its key advantages?

Foundation • 0-2 Yrs

String objects cannot be modified once instantiated in the String Constant Pool (SCP). Immutability ensures thread safety without synchronization, security (preventing tampering with network/DB connections), caching benefits (hashCode is cached at creation), and prevents heap bloat through string pooling.

Q3. What is the difference between StringBuffer and StringBuilder?

Foundation • 0-2 Yrs

StringBuffer is mutable and thread-safe because its public methods are synchronized, making it slower in single-threaded environments. StringBuilder (introduced in Java 5) is mutable and non-synchronized, delivering superior performance for high-throughput single-threaded string manipulation.

Q4. Explain the internal working of HashMap in Java 8.

Foundation • 0-2 Yrs

HashMap stores key-value pairs in an array of Node buckets. When hash collisions occur, entries form a linked list. Starting in Java 8, when a bucket contains more than TREEIFY_THRESHOLD (8) elements and the table capacity is at least 64, the linked list converts to a Balanced Red-Black Tree, reducing worst-case search complexity from O(n) to O(log n).

Q5. What is the contract between equals() and hashCode() in Java?

Foundation • 0-2 Yrs

If two objects are equal according to equals(), they must produce the exact same integer hashCode(). However, if two objects produce the same hashCode (collision), they are not necessarily equal. Failing to override both when using hash-based collections (HashMap, HashSet) leads to lost or duplicate entries.

Q6. Differentiate between ArrayList and LinkedList in Java.

Foundation • 0-2 Yrs

ArrayList uses a dynamic resizable array, offering O(1) random access via index, but O(n) element insertion/deletion in the middle due to array copying. LinkedList implements a doubly-linked list, providing O(1) head/tail insertions/deletions, but O(n) random search traversal with higher per-node memory overhead.

Q7. What is the difference between '==' operator and equals() method?

Foundation • 0-2 Yrs

The '==' operator compares object reference memory addresses (verifying if both point to the same heap location). The equals() method compares logical content equality when properly overridden (e.g., in String, Integer). For un-overridden classes, equals() defaults to reference comparison.

Q8. Explain method overloading vs method overriding with rules.

Foundation • 0-2 Yrs

Overloading occurs in the same class when methods share the same name but differ in parameter count or types (compile-time polymorphism). Overriding occurs in child classes providing a specific implementation of a parent method with the exact same signature and return type (or covariant), without reducing visibility (runtime polymorphism).

Q9. What are Java checked vs unchecked exceptions?

Foundation • 0-2 Yrs

Checked exceptions inherit from Exception (excluding RuntimeException) and must be handled at compile-time via try-catch or declared with 'throws' (e.g., IOException, SQLException). Unchecked exceptions inherit from RuntimeException and occur at runtime due to programming flaws (e.g., NullPointerException, ArrayIndexOutOfBoundsException).

Q10. What is the purpose of the 'finally' block and when does it not execute?

Foundation • 0-2 Yrs

The 'finally' block always executes after try-catch for resource cleanup (closing DB connections, file streams), regardless of whether an exception was thrown or caught. It does not execute only if System.exit() is invoked, the JVM crashes, or the thread executing the try block is killed.

Q11. Explain the difference between abstract classes and interfaces in Java 8+.

Foundation • 0-2 Yrs

Abstract classes can maintain instance state, constructors, and instance variables, and support single inheritance. Interfaces cannot have state (variables are public static final) but support multiple inheritance. Starting in Java 8, interfaces can contain default and static methods with concrete bodies, and in Java 9, private methods.

Q12. What are Java wrapper classes and how does Autoboxing work?

Foundation • 0-2 Yrs

Wrapper classes (Integer, Double, Boolean, etc.) encapsulate primitive types into heap objects to enable their use in Collections. Autoboxing is the automatic conversion of primitives into their corresponding wrapper objects by the compiler (e.g., int to Integer via Integer.valueOf()), while unboxing extracts the primitive value.

Q13. What is the Java Garbage Collector and how can you request collection?

Foundation • 0-2 Yrs

The Garbage Collector is an automatic memory management daemon thread in the JVM that identifies and reclaims memory allocated to unreachable heap objects. You can suggest garbage collection using System.gc() or Runtime.getRuntime().gc(), but JVM execution is not guaranteed immediately.

Q14. Explain the 'final', 'finally', and 'finalize' keywords.

Foundation • 0-2 Yrs

'final' is an access modifier applied to variables (constants), methods (cannot be overridden), and classes (cannot be subclassed). 'finally' is a block attached to try-catch for cleanup. 'finalize()' was an Object method invoked before reclamation, deprecated in Java 9 and removed in modern Java.

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

Foundation • 0-2 Yrs

Fail-fast iterators (e.g., in ArrayList, HashMap) immediately throw ConcurrentModificationException if the underlying collection is modified during iteration (detected via modCount). Fail-safe iterators (e.g., in CopyOnWriteArrayList, ConcurrentHashMap) operate on a clone or snapshot of the collection, allowing concurrent updates.

Q16. Explain Java 21 Virtual Threads (Project Loom) and how they differ from platform threads.

Experienced • 3-5+ Yrs

Platform threads are 1:1 wrappers over operating system kernel threads, consuming roughly 1MB of stack memory and limited to a few thousand per JVM. Virtual Threads (Java 21) are lightweight user-mode threads managed directly by the JVM runtime, consuming mere bytes of memory. Millions can run concurrently; when a virtual thread blocks on I/O, the JVM unmounts it from its carrier platform thread, maximizing CPU utilization.

Q17. Explain the JVM memory model: Heap (Young/Old Generation), Metaspace, and Stack.

Experienced • 3-5+ Yrs

The JVM memory is split into: Heap (shared memory storing objects, divided into Young Generation [Eden, Survivor S0/S1] for short-lived objects and Old/Tenured Generation for long-lived objects), Metaspace (native memory storing class metadata, replacing PermGen in Java 8), and JVM Stacks (per-thread memory holding stack frames, local primitive variables, and references).

Q18. How does ConcurrentHashMap achieve high concurrency without locking the entire table?

Experienced • 3-5+ Yrs

In Java 8+, ConcurrentHashMap avoids table-wide locking and segment locks. It uses Compare-And-Swap (CAS) instructions for lock-free bucket initialization and synchronization (synchronized block) locked exclusively on the first node of each specific bucket list/tree, allowing parallel concurrent writes across different buckets.

Q19. Explain Java Memory Model (JMM) happens-before relationship and the 'volatile' keyword.

Experienced • 3-5+ Yrs

The JMM defines how threads interact through memory. The 'volatile' keyword guarantees visibility (writes to a volatile variable are immediately flushed to main memory and subsequent reads see the latest value) and prevents instruction reordering by inserting memory barriers, but does not guarantee atomicity for compound operations like count++.

Q20. How do you prevent Deadlocks in multi-threaded Java applications?

Experienced • 3-5+ Yrs

Deadlocks occur when threads hold locks while waiting for locks held by each other in a circular chain. Prevention strategies include: enforcing a strict global lock acquisition hierarchy, using ReentrantLock.tryLock() with timeouts, avoiding nested synchronized blocks, and using higher-level java.util.concurrent utilities.

Q21. Explain the Spring Bean Lifecycle from instantiation to destruction.

Experienced • 3-5+ Yrs

1. Instantiation (constructor call) -> 2. Populate Properties (dependency injection) -> 3. BeanNameAware / BeanFactoryAware -> 4. BeanPostProcessor beforeInitialization -> 5. @PostConstruct / InitializingBean.afterPropertiesSet() / custom init-method -> 6. BeanPostProcessor afterInitialization -> 7. Bean is ready -> 8. PreDestroy / DisposableBean.destroy().

Q22. What is the difference between @Component, @Service, and @Repository in Spring?

Experienced • 3-5+ Yrs

@Component is the generic stereotype for any Spring-managed component. @Service is a specialized stereotype for business logic layer classes. @Repository is for data access layers, providing automatic translation of database platform exceptions into Spring's unified DataAccessException hierarchy.

Q23. How does Spring Boot Auto-Configuration work under the hood?

Experienced • 3-5+ Yrs

Spring Boot scans META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. Each auto-configuration class evaluates conditional annotations such as @ConditionalOnClass, @ConditionalOnMissingBean, and @ConditionalOnProperty to decide whether to register beans automatically based on classpath dependencies.

Q24. Explain Java 8 Streams: intermediate vs terminal operations.

Experienced • 3-5+ Yrs

Streams process data declaratively. Intermediate operations (filter, map, sorted, flatMap) are lazy and return a new Stream without executing computation until a terminal operation is reached. Terminal operations (collect, forEach, reduce, count) trigger pipeline execution and produce a result or side-effect, closing the stream.

Q25. What is the difference between CompletableFuture and Future in Java?

Experienced • 3-5+ Yrs

Future represents an asynchronous computation but requires blocking via .get() or polling via .isDone() to retrieve results. CompletableFuture (Java 8) supports non-blocking functional chaining (thenApply, thenCompose, thenCombine), exception handling (exceptionally, handle), and manual completion via .complete().

Q26. How do you handle Distributed Transactions across Microservices (Saga Pattern)?

Experienced • 3-5+ Yrs

Distributed 2PC (Two-Phase Commit) introduces high latency and single points of failure. The Saga pattern executes a sequence of local transactions across services. If a step fails, the saga executes compensating transactions in reverse order to rollback state. Sagas can be Choreography-based (event-driven via Kafka) or Orchestration-based (central coordinator).

Q27. Explain ClassLoader hierarchy in Java (Bootstrap, Platform/Extension, Application).

Experienced • 3-5+ Yrs

The JVM uses a delegation model: when a class is requested, a ClassLoader delegates up to its parent before searching itself. Bootstrap ClassLoader loads core JDK runtime classes (rt.jar / java.base). Platform/Extension ClassLoader loads platform extensions. Application/System ClassLoader loads application classes on the user CLASSPATH.

Q28. What are Java Records and Sealed Classes introduced in modern Java?

Experienced • 3-5+ Yrs

Records (Java 16) are concise, immutable data carriers that automatically generate getters, constructor, equals(), hashCode(), and toString(). Sealed Classes (Java 17) restrict which other classes or interfaces may extend or implement them using the 'permits' clause, enabling exhaustive pattern matching.

Q29. How does Spring Security implement JWT authentication in REST APIs?

Experienced • 3-5+ Yrs

A client sends credentials to an authentication endpoint. Upon validation, the server generates a signed JSON Web Token containing claims. Subsequent client requests attach this token in the 'Authorization: Bearer ' header. A custom OncePerRequestFilter intercepts requests, validates the signature, extracts user details, and populates the SecurityContextHolder.

Q30. Explain database connection pool tuning in Spring Boot using HikariCP.

Experienced • 3-5+ Yrs

HikariCP is the default high-performance connection pool in Spring Boot. Tuning involves setting maximumPoolSize (often formula: pool_size = Tn * (core_count * 2) + effective_spindle_count), minimumIdle, connectionTimeout (max wait before throwing SQLException), and idleTimeout to prevent thread starvation and DB socket leaks.

Q31. Write a Java 8 Stream solution to find the first non-repeating character in a String.

Live Coding Challenge

We stream character code points, group by identity with LinkedHashMap to preserve order, count frequencies, filter for count == 1, and retrieve the first element.

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class FirstUnique {
    public static Optional<Character> findFirst(String input) {
        return input.chars()
            .mapToObj(c -> (char) c)
            .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()))
            .entrySet().stream()
            .filter(e -> e.getValue() == 1L)
            .map(Map.Entry::getKey)
            .findFirst();
    }
}

Q32. Implement a thread-safe Singleton pattern in Java using Bill Pugh Singleton.

Live Coding Challenge

The Bill Pugh method uses an inner static helper class. The JVM guarantees thread safety and lazy initialization when the inner class is referenced for the first time.

public class Singleton {
    private Singleton() {}

    private static class Helper {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return Helper.INSTANCE;
    }
}

Q33. Reverse a Singly Linked List in Java iteratively in O(N) time and O(1) space.

Live Coding Challenge

We maintain three pointers: prev, current, and next, redirecting each node's next reference backwards.

class ListNode {
    int val;
    ListNode next;
    ListNode(int val) { this.val = val; }
}

public class ReverseList {
    public ListNode reverse(ListNode head) {
        ListNode prev = null, curr = head;
        while (curr != null) {
            ListNode nextNode = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextNode;
        }
        return prev;
    }
}

Q34. Find the longest substring without repeating characters in O(N) time (Sliding Window).

Live Coding Challenge

We track characters and their most recent indices in a HashMap while expanding the window, adjusting the start pointer when duplicate characters are encountered.

import java.util.*;

public class LongestUniqueSubstring {
    public int lengthOfLongestSubstring(String s) {
        Map<Character, Integer> map = new HashMap<>();
        int maxLen = 0, start = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (map.containsKey(c)) {
                start = Math.max(start, map.get(c) + 1);
            }
            map.put(c, i);
            maxLen = Math.max(maxLen, i - start + 1);
        }
        return maxLen;
    }
}

Q35. Implement a custom Producer-Consumer queue using wait() and notifyAll().

Live Coding Challenge

A shared bounded queue synchronizes on a lock object, calling wait() when the buffer is full/empty and notifyAll() after state changes.

import java.util.*;

public class CustomQueue<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;

    public CustomQueue(int capacity) { this.capacity = capacity; }

    public synchronized void produce(T item) throws InterruptedException {
        while (queue.size() == capacity) wait();
        queue.add(item);
        notifyAll();
    }

    public synchronized T consume() throws InterruptedException {
        while (queue.isEmpty()) wait();
        T item = queue.poll();
        notifyAll();
        return item;
    }
}

Q36. Write a program to detect a cycle in a linked list using Floyd's Cycle-Finding Algorithm.

Live Coding Challenge

Two pointers (slow moving 1 step, fast moving 2 steps). If they meet, a cycle exists; if fast reaches null, no cycle exists.

public class CycleDetection {
    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        ListNode slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) return true;
        }
        return false;
    }
}

Q37. Write a Java 8 Stream pipeline to partition a list of integers into Even and Odd numbers.

Live Coding Challenge

We use Collectors.partitioningBy(n -> n % 2 == 0) which splits elements into a Map>.

import java.util.*;
import java.util.stream.Collectors;

public class PartitionEvenOdd {
    public static Map<Boolean, List<Integer>> partition(List<Integer> list) {
        return list.stream()
            .collect(Collectors.partitioningBy(n -> n % 2 == 0));
    }
}

Q38. Implement an LRU Cache in Java using LinkedHashMap with accessOrder=true.

Live Coding Challenge

By extending LinkedHashMap and overriding removeEldestEntry(), we obtain an O(1) LRU cache with clean minimal code.

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;
    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;
    }
}

Q39. Merge two sorted arrays in-place without extra space in Java.

Live Coding Challenge

We iterate backwards from the end of both arrays and insert the largest elements into the allocated buffer of the first array.

public class MergeSortedArrays {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = m - 1, p2 = n - 1, p = m + n - 1;
        while (p1 >= 0 && p2 >= 0) {
            nums1[p--] = (nums1[p1] > nums2[p2]) ? nums1[p1--] : nums2[p2--];
        }
        while (p2 >= 0) nums1[p--] = nums2[p2--];
    }
}

Q40. Write a method in Java to check if two strings are Anagrams using frequency counting.

Live Coding Challenge

We use a fixed 26-element integer frequency array, incrementing for the first string and decrementing for the second string.

public class AnagramCheck {
    public static boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;
        int[] counts = new int[26];
        for (int i = 0; i < s.length(); i++) {
            counts[s.charAt(i) - 'a']++;
            counts[t.charAt(i) - 'a']--;
        }
        for (int count : counts) if (count != 0) return false;
        return true;
    }
}