Java is one of the most asked languages in Indian IT and product company interviews. These Java interview questions cover OOP, JVM, strings and exceptions for freshers, then collections, HashMap internals, multithreading, Java 8+ streams, memory management and garbage collection for experienced Java developers.
40 questions · Updated
Fundamentals, definitions and simple scenarios. Good for freshers and warm-ups.
The JVM (Java Virtual Machine) runs Java bytecode and makes Java platform-independent.
The JRE (Java Runtime Environment) contains the JVM plus the core libraries needed to run Java programs.
The JDK (Java Development Kit) contains the JRE plus development tools such as the javac compiler and debugger.
Since Java 11, the JDK is the standard download.
Immutability makes strings safe to share: they can be stored in the string pool and reused, used as HashMap keys because their hash code never changes, and passed between threads without synchronisation.
It also improves security, because values like file paths or URLs cannot be changed after validation.
StringBuilder is used when a string is modified many times.
== compares references for objects, checking whether two variables point to the same object, and compares values for primitives. equals() compares logical content when a class overrides it, as String does. When you override equals(), you must also override hashCode() so equal objects have the same hash code, otherwise they behave incorrectly in HashMap and HashSet.
The Java compiler turns source code into bytecode (.class files) rather than machine code for one processor.
Any device with a Java Virtual Machine can run that bytecode, and the JVM translates it into native instructions, using a just-in-time compiler for speed.
So the same compiled program runs on Windows, Linux or macOS: "write once, run anywhere".
The JVM itself is platform-specific.
It is the entry point the JVM calls to start a program. public lets the JVM call it from outside the class, static means it can be called without creating an object, void means it returns nothing, main is the name the JVM looks for, and String[] args holds command-line arguments. Since Java 21 there is a preview of simpler instance main methods for beginners.
Each primitive type has a wrapper class: int has Integer, double has Double, boolean has Boolean and so on.
Collections can only store objects, so wrappers are needed for a List<Integer>.
Autoboxing converts a primitive to its wrapper automatically, and unboxing does the reverse.
Watch out for NullPointerException when unboxing null, and for comparing Integer objects with ==, which only works reliably for small cached values (-128 to 127).
String is immutable, so every change creates a new object; it suits values that do not change.
StringBuilder is mutable and fast, and is the right choice for building strings in loops.
StringBuffer is also mutable but its methods are synchronized, which makes it thread-safe but slower; it is rarely needed today.
The compiler already optimises simple string concatenation with +.
final is a keyword: a final variable cannot be reassigned, a final method cannot be overridden and a final class cannot be extended. finally is a block after try/catch that always runs, used for cleanup. finalize was a method called by the garbage collector before removing an object; it is unreliable, deprecated since Java 9 and should not be used. try-with-resources and Cleaner replace it.
static members belong to the class rather than to any object.
A static variable is shared by all instances, such as a counter of created objects.
A static method can be called without an object, such as Math.max, but cannot use instance variables or this.
Static blocks run once when the class loads, and static nested classes do not need an outer instance.
Overloading means several methods in the same class with the same name but different parameter lists, chosen by the compiler at compile time, such as add(int, int) and add(double, double).
Overriding means a subclass redefines a parent method with the same signature, chosen at runtime based on the actual object.
Overriding methods should use @Override, cannot reduce visibility and cannot throw broader checked exceptions.
An abstract class can have instance fields, constructors, and both abstract and concrete methods, and a class can extend only one.
An interface defines a contract; since Java 8 it can have default and static methods, and since Java 9 private methods, but no instance state, and a class can implement many.
I use interfaces for capabilities, such as Comparable or Runnable, and abstract classes for shared base code.
Constructor chaining means one constructor calling another, so initialisation code is not duplicated. this(...) calls another constructor in the same class, and super(...) calls a parent constructor; either must be the first statement. If you do not call super explicitly, the compiler inserts super() to call the parent's no-argument constructor.
An array has a fixed size set when it is created, can hold primitives or objects, and is accessed with [].
An ArrayList is a resizable list from the Collections Framework that grows automatically, holds only objects (so primitives are boxed), and offers methods such as add, remove and contains.
Arrays are slightly faster and lighter; ArrayList is more convenient for most code.
Applied problems, trade-offs and questions about your own projects.
Checked exceptions, such as IOException and SQLException, are checked at compile time and must be caught or declared with throws.
Unchecked exceptions extend RuntimeException, such as NullPointerException and IllegalArgumentException, and usually indicate programming errors.
Errors like OutOfMemoryError are serious problems that applications should not try to catch.
HashMap stores entries in an array of buckets.
It calculates the key's hashCode, spreads it and uses it to find a bucket index.
Entries in the same bucket form a linked list, which turns into a balanced red-black tree when it has more than eight entries (Java 8+).
When the size exceeds capacity times the load factor (0.75 by default), the array doubles and entries are rehashed.
Lookups are O(1) on average.
ArrayList uses a resizable array, so access by index is O(1) and it is cache-friendly, but inserting or removing in the middle shifts elements.
LinkedList is a doubly linked list, so inserting or removing at a known node is O(1) but access by index is O(n) and it uses more memory.
In practice ArrayList is the better default almost always.
Lambda expressions and functional interfaces, the Stream API for processing collections with map, filter and collect, Optional to represent values that may be missing, default and static methods in interfaces, method references, and the new java.time date and time API. Later versions added var, records, switch expressions, text blocks, sealed classes and virtual threads (Java 21).
HashMap is not thread-safe and allows one null key and null values.
Hashtable is a legacy class where every method is synchronized, so it is thread-safe but slow, and allows no nulls.
ConcurrentHashMap is thread-safe with high concurrency: reads do not lock and writes lock only a small part of the map, using CAS operations; it allows no nulls.
For multi-threaded code, ConcurrentHashMap is the right choice.
HashSet is backed by a HashMap.
Each element you add is stored as a key in that map with a constant dummy value, so uniqueness comes from the map's keys, using hashCode and equals.
That is why objects stored in a HashSet must implement hashCode and equals correctly.
LinkedHashSet keeps insertion order and TreeSet keeps elements sorted.
Comparable defines a class's natural ordering through its own compareTo method, such as String sorting alphabetically, so it is implemented by the class itself.
Comparator defines an external ordering in a separate object, so you can sort the same class in many ways without changing it.
Java 8 made comparators easy to build, such as Comparator.comparing(Employee::getSalary).reversed().thenComparing(Employee::getName).
Fail-fast iterators, used by ArrayList and HashMap, throw ConcurrentModificationException if the collection is structurally changed while iterating, except through the iterator's own remove method.
Fail-safe (weakly consistent) iterators, used by concurrent collections such as CopyOnWriteArrayList and ConcurrentHashMap, work on a snapshot or tolerate changes and never throw that exception.
To remove items while looping, use iterator.remove() or removeIf.
Introduced in Java 7, try-with-resources automatically closes any resource that implements AutoCloseable, such as files, streams and database connections, when the block ends, even if an exception is thrown.
It replaces error-prone finally blocks.
If closing also throws, that exception is added as a suppressed exception instead of hiding the original one.
try (BufferedReader reader = Files.newBufferedReader(Path.of("data.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
process(line);
}
} catch (IOException e) {
log.error("Could not read file", e);
}Extend Exception for a checked exception that callers must handle, or RuntimeException for an unchecked one, which is more common for business rule violations.
Provide constructors that accept a message and a cause, so the original exception is not lost.
Give it a clear name, such as InsufficientBalanceException, and in Spring map it to the right HTTP status in a global exception handler.
You can extend Thread, or better, implement Runnable and pass it to a Thread or an executor, which keeps the task separate from the threading mechanism.
Callable is like Runnable but returns a result and can throw checked exceptions; submitting it to an ExecutorService gives a Future to get the result.
In Java 21, virtual threads are created with Thread.ofVirtual() or Executors.newVirtualThreadPerTaskExecutor().
Creating a new platform thread for every task is expensive and uncontrolled.
An ExecutorService manages a pool of reusable threads and a task queue, created through Executors or ThreadPoolExecutor.
You submit tasks and get Futures back, and you must shut the executor down when finished.
In production I size pools deliberately and use bounded queues so the system degrades gracefully under load.
Optional is a container that may or may not hold a value, used as a method return type to make "no result" explicit and avoid returning null, such as Optional<User> findByEmail(String email).
Use map, filter, orElse, orElseGet and orElseThrow rather than calling get() without checking.
It should not be used for fields, method parameters or collections, where an empty collection is better.
map transforms each element into exactly one new element, such as mapping users to their names. flatMap transforms each element into a stream and flattens all those streams into one, such as turning a list of orders into a single stream of all their items. With Optional, flatMap is used when the mapping function itself returns an Optional.
List<String> allItems = orders.stream()
.flatMap(order -> order.getItems().stream())
.map(Item::getName)
.distinct()
.toList();Intermediate operations such as filter, map, sorted and distinct return a new stream and are lazy: nothing runs until a terminal operation is called.
Terminal operations such as collect, forEach, reduce, count and findFirst produce a result or side effect and end the stream.
Laziness allows short-circuiting, so findFirst can stop after the first match.
A stream can be used only once.
Serialization converts an object into a byte stream so it can be saved or sent over a network, and deserialization rebuilds it.
A class opts in by implementing Serializable, fields marked transient are skipped, and serialVersionUID controls version compatibility.
Java's built-in serialization has serious security risks when reading untrusted data, so modern systems usually use JSON (Jackson), Protocol Buffers or similar formats instead.
System design, deep internals, leadership and tough follow-ups.
synchronized ensures only one thread runs a block at a time on a given lock and also guarantees memory visibility. volatile guarantees visibility of a variable's latest value across threads but does not make compound actions like count++ atomic. ReentrantLock offers more control, such as tryLock, timeouts and fairness, and atomic classes like AtomicInteger give lock-free thread-safe operations.
The JVM automatically frees objects that are no longer reachable from GC roots, such as thread stacks and static fields.
The heap is divided into generations: most objects die young in the young generation, which is collected often and quickly, and survivors move to the old generation.
G1 is the default collector; ZGC and Shenandoah offer very low pause times.
Tuning involves heap size and choosing the right collector.
Virtual threads are lightweight threads managed by the JVM rather than the operating system.
Millions can exist at once, and when one blocks on I/O, the JVM parks it and frees the carrier thread.
This lets you write simple blocking, thread-per-request code that scales like asynchronous code.
They are best for I/O-bound workloads and should not be pooled.
The heap stores all objects and is shared by threads; it is managed by the garbage collector and split into young and old generations.
Each thread has its own stack holding method frames, local variables and references; deep recursion causes StackOverflowError.
Metaspace (which replaced PermGen in Java 8) stores class metadata in native memory.
There is also the program counter register per thread and the native method stack.
Classes are loaded lazily when first used, by a hierarchy of class loaders: the bootstrap loader for core Java classes, the platform loader, and the application loader for your classpath.
They use parent delegation, asking the parent first, so core classes cannot be replaced.
Loading is followed by linking (verification, preparation and resolution) and initialisation, which runs static blocks.
Custom class loaders enable plugins and hot reloading.
A deadlock happens when two or more threads each hold a lock and wait for a lock another holds, so none can continue.
It needs mutual exclusion, hold and wait, no pre-emption and circular wait.
I prevent it by always acquiring locks in the same global order, holding locks for as short a time as possible, using tryLock with a timeout, and preferring higher-level concurrency utilities.
Thread dumps from jstack show deadlocked threads.
CompletableFuture represents an asynchronous computation that you can chain and combine without blocking. supplyAsync starts a task, thenApply transforms the result, thenCompose chains another async call, thenCombine and allOf combine several tasks, and exceptionally or handle deal with errors.
It is useful for calling several services in parallel and combining their results.
Pass your own executor rather than relying on the common pool for I/O work.
CompletableFuture<User> user = CompletableFuture.supplyAsync(() -> userService.get(id), executor);
CompletableFuture<List<Order>> orders = CompletableFuture.supplyAsync(() -> orderService.forUser(id), executor);
Profile profile = user.thenCombine(orders, Profile::new)
.orTimeout(2, TimeUnit.SECONDS)
.join();Records (Java 16) are concise immutable data classes: record Point(int x, int y) {} generates the constructor, accessors, equals, hashCode and toString.
Sealed classes (Java 17) restrict which classes can extend them with permits, so the compiler knows every subtype.
Pattern matching for instanceof and for switch (Java 21), including record patterns, lets you test a type and extract its fields in one step, and the compiler checks that a switch over a sealed type covers every case.
Make the class final so it cannot be subclassed, make all fields private and final, set them only in the constructor, provide no setters, and make defensive copies of mutable inputs and outputs such as lists and dates, or use List.copyOf.
Immutable objects are thread-safe without synchronisation and safe to use as map keys.
Records give most of this automatically, but still need defensive copies for mutable components.
The simplest and safest way is an enum with a single INSTANCE, which the JVM guarantees is created once and which resists reflection and serialization attacks.
Another common way is the initialisation-on-demand holder idiom, a private static nested class holding the instance, which is lazy and thread-safe without locks.
Double-checked locking needs a volatile field to be correct.
In Spring applications, beans are singletons by default, so hand-written singletons are rarely needed.
Generics let classes and methods work with any type while keeping compile-time type safety, such as List<String> instead of a raw List that needs casting.
Bounded types such as <T extends Number> and wildcards such as ? extends and ? super (remember PECS: producer extends, consumer super) add flexibility.
Type erasure means generic type information is removed at compile time for backward compatibility, so at runtime List<String> and List<Integer> are the same class, and you cannot create new T() or check instanceof List<String>.
Tasks you build live in 30 to 60 minutes. What interviewers look for, plus a compact solution to compare with yours.
A very common fresher question.
Use a char array with two pointers swapping from both ends.
Mention that StringBuilder.reverse() exists and handles surrogate pairs correctly.
static String reverse(String s) {
char[] chars = s.toCharArray();
for (int i = 0, j = chars.length - 1; i < j; i++, j--) {
char tmp = chars[i];
chars[i] = chars[j];
chars[j] = tmp;
}
return new String(chars);
}Tests the Stream API and collectors. groupingBy with counting builds the map in one expression; use a LinkedHashMap to keep the order of first appearance.
Map<Character, Long> freq = "programming".chars()
.mapToObj(c -> (char) c)
.collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()));
// {p=1, r=2, o=1, g=2, a=1, m=2, i=1, n=1}Interviewers check handling of duplicates and short lists. A stream solution is short; a single loop tracking the top two values is O(n) with no sorting.
static OptionalInt secondHighest(List<Integer> nums) {
return nums.stream()
.mapToInt(Integer::intValue)
.distinct()
.boxed()
.sorted(Comparator.reverseOrder())
.skip(1)
.mapToInt(Integer::intValue)
.findFirst();
}A common string problem.
Count characters in a LinkedHashMap, which keeps insertion order, then return the first with a count of one.
It runs in O(n).
static Character firstUnique(String s) {
Map<Character, Integer> counts = new LinkedHashMap<>();
for (char c : s.toCharArray()) counts.merge(c, 1, Integer::sum);
return counts.entrySet().stream()
.filter(e -> e.getValue() == 1)
.map(Map.Entry::getKey)
.findFirst()
.orElse(null);
}See all Backend Developer interview questions, covering Node.js, Express.js, NestJS, Python, Django and more.