Java Interview Questions and Answers

The JVM runs bytecode. The JRE is the JVM plus the standard libraries needed to run a program. The JDK is the JRE plus the tools needed to build one.

• JVM: the virtual machine that loads classes, checks bytecode, and runs it with an interpreter and a JIT compiler. It is platform specific, which is what makes compiled Java portable.
• JRE: JVM + core class libraries (java.lang, java.util and so on). Since Java 11 Oracle no longer ships a separate JRE, but the idea is still useful.
• JDK: JRE + javac, jar, jlink, jshell, debuggers and profilers.

Flow: .java source -> javac -> .class bytecode -> JVM -> machine code. "Write once, run anywhere" works because only the JVM is platform specific.

What they are checking: Whether you understand the build and run pipeline, not just three acronyms

A String cannot change after it is created. Java does this on purpose, for safety, caching and speed.

• String pool: identical literals share one object, which only works if nobody can modify it.
• Thread safety: immutable objects can be shared between threads without locking.
• Security: strings carry class names, file paths, URLs and credentials. If they could change after validation, checks could be bypassed.
• Hash caching: hashCode() is computed once and cached, so Strings are fast HashMap keys.

String s = "java";
s.concat(" 21");          // returns a new String, s is unchanged
System.out.println(s);    // java

Every "modification" such as concat, replace or toUpperCase returns a new object. So changing a string again and again in a loop creates a lot of garbage. This is why StringBuilder exists.

What they are checking: Whether you can explain a design decision and what it leads to

String is immutable, StringBuilder is mutable and not thread safe, StringBuffer is mutable and synchronized.

Use StringBuilder when building text in a loop inside one thread. Use StringBuffer only in old code that shares one buffer between threads (rare, since you can usually avoid sharing).

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 5; i++) sb.append(i).append(',');
sb.setLength(sb.length() - 1);
System.out.println(sb); // 0,1,2,3,4

For a one-line concatenation the compiler already optimises +, so do not replace it with a builder.

What they are checking: Whether you choose the right tool for building strings and know the thread safety cost

== compares references for objects (and values for primitives). equals() compares the content when the class overrides it.

String a = new String("hi");
String b = new String("hi");
System.out.println(a == b);       // false, two objects
System.out.println(a.equals(b));  // true, same characters

String c = "hi", d = "hi";
System.out.println(c == d);       // true, same pooled literal

• The default Object.equals() behaves like ==.
• String, wrapper classes, List, and records override equals.
• Never compare strings with ==. Use equals, or Objects.equals(a, b) when either may be null.
• Beware Integer caching: Integer.valueOf(127) == Integer.valueOf(127) is true but 1000 is not.

What they are checking: Whether you know reference vs value comparison and the string pool trap

If two objects are equal according to equals(), they must return the same hashCode(). The reverse is not required (collisions are allowed).

If you override equals without hashCode, equal objects usually get different hash codes, so hash-based collections break:

class P { String n; P(String n){this.n=n;}
  @Override public boolean equals(Object o){ return o instanceof P p && p.n.equals(n); } }

Set<P> s = new HashSet<>();
s.add(new P("a"));
System.out.println(s.contains(new P("a"))); // usually false

The lookup computes a different bucket, so the equal element is never found.

Rules for equals: reflexive, symmetric, transitive, consistent, and x.equals(null) is false. A correct pair:

@Override public int hashCode(){ return java.util.Objects.hash(n); }

Prefer records or IDE generated methods. Use only fields that do not change while the object is a map key.

What they are checking: Whether you understand why hash collections need both methods

ArrayList is backed by a resizable array and LinkedList by a doubly linked list. ArrayList wins for almost every real workload.

LinkedList also implements Deque, so it works as a queue, but ArrayDeque is usually faster. In practice use ArrayList by default. Use LinkedList only for frequent insertions through an Iterator or ListIterator at known positions.

Tip: pass an initial capacity (new ArrayList<>(10_000)) when you know the size to avoid repeated array copies.

What they are checking: Whether you reason about speed and memory, and do not repeat the myth that linked lists are faster for inserts

HashMap stores entries in an array of buckets. The key's hash decides the bucket, and collisions are chained.

Steps for put(key, value):

1. Compute hashCode() of the key and spread the bits (h ^ (h >>> 16)).
2. Bucket index = (n - 1) & hash, where n is the table size (a power of two).
3. If the bucket is empty, store a new node. Otherwise walk the chain, comparing with equals, and replace the value if the key exists, else append.
4. Since Java 8, a chain longer than 8 (when the table size is at least 64) turns into a red-black tree. The worst case is then O(log n).
5. When size exceeds capacity * 0.75 (the load factor), the table doubles and entries are redistributed.

Facts to mention: default capacity 16, one null key allowed, not thread safe, iteration order not guaranteed. get is average O(1). Keys should be immutable, and a good hashCode keeps chains short.

What they are checking: The most common Java collections question: depth on hashing, collisions and resizing

Checked exceptions are verified by the compiler and must be caught or declared. Unchecked exceptions (subclasses of RuntimeException and Error) are not.

• Checked: IOException, SQLException. They represent recoverable conditions outside the program's control. You must write try/catch or throws.
• Unchecked: NullPointerException, IllegalArgumentException, IndexOutOfBoundsException. They usually signal programming bugs.
• Error: OutOfMemoryError, StackOverflowError. Do not catch them in normal code.

void read() throws java.io.IOException {
    try (var r = java.nio.file.Files.newBufferedReader(java.nio.file.Path.of("a.txt"))) {
        System.out.println(r.readLine());
    }
}

Modern guidance: use unchecked exceptions for most business errors. Keep checked ones where the caller can really recover. Never ignore an exception silently. Keep the cause with new MyException("msg", e).

What they are checking: Whether you know the hierarchy and a sensible exception design philosophy

They are unrelated: final is a modifier, finally is a block, and finalize() is a deprecated method.

• final: a final variable cannot be reassigned. A final method cannot be overridden. A final class cannot be extended (String is final). A final reference can still point to a mutable object.
• finally: a block after try/catch that runs whether or not an exception occurred. It is used for cleanup. It does not run if the JVM exits (System.exit) or crashes.
• finalize(): a method the GC could call before reclaiming an object. It has been deprecated for removal since Java 18 because it is unpredictable and slow. Use try-with-resources or Cleaner instead.

try { return 1; } finally { System.out.println("cleanup"); }

The finally block above still prints before the method returns.

What they are checking: A classic wording trap: checks that you can separate the three terms

An interface defines a contract (what), an abstract class gives partial implementation plus state (how).

Since Java 8, interfaces can have default methods, so the line is less clear. But interfaces still cannot hold instance state.

Choose an interface for capabilities that unrelated classes share (Comparable, Runnable). Choose an abstract class when subclasses share fields and common code (a template-method base class). Java 17+ adds sealed interfaces to restrict which classes may implement them.

What they are checking: Whether you can choose between them using design reasons

Overloading is multiple methods with the same name and different parameters in one class (compile-time polymorphism). Overriding is a subclass redefining a superclass method with the same signature (runtime polymorphism).

synchronized gives mutual exclusion and memory visibility: only one thread at a time can run a block guarded by the same monitor lock.

volatile guarantees visibility and ordering of a single variable across threads. It does not make compound actions atomic.

A lambda is a short anonymous function. It can be used wherever a functional interface (an interface with exactly one abstract method) is expected.

A Stream is a pipeline for processing a sequence of elements declaratively. It has a source, zero or more lazy intermediate operations, and one terminal operation that triggers execution.

The garbage collector frees heap memory by itself. It frees objects that can no longer be reached from GC roots (thread stacks, static fields, JNI references).

IoC means the framework creates and wires objects instead of your code calling new. Dependency Injection is how it supplies a class its collaborators.

The four pillars are encapsulation, inheritance, polymorphism and abstraction.

Java is always pass by value. For objects, the value that is copied is the reference.

Extend Thread, implement Runnable (or Callable), or, in modern code, submit tasks to an executor.

A record (final since Java 16) is a compact immutable data carrier. The compiler generates the constructor, accessors, equals, hashCode and toString from the component list.

@Controller returns view names by default (for server-rendered pages). @RestController adds @ResponseBody, so return values are written to the HTTP body as JSON.

Annotate a class with @Entity, extend JpaRepository, and Spring generates the implementation.

Spring wraps the bean in a proxy. The proxy opens a transaction before the method. It commits on normal return. It rolls back on a RuntimeException or Error (not on checked exceptions by default).

ConcurrentHashMap is a thread-safe hash map. It allows concurrent reads and fine-grained writes without locking the whole map.

The Executor framework separates task submission from execution. You submit tasks, and a pool of reusable threads runs them.

A deadlock is when two or more threads each hold a lock the other needs, so none can move on.

@SpringBootApplication combines @Configuration, @ComponentScan and @EnableAutoConfiguration.

The default scope is singleton: one instance per container. Others are prototype (new instance per injection or lookup), and for web apps request, session and application.

All four are stereotype annotations that register a class as a bean through component scanning. The last three are specialisations of @Component that add meaning.

Try-with-resources closes any resource that implements AutoCloseable for you. It closes in reverse order of declaration, even if an exception occurs.

CompletableFuture is a Future you can compose without blocking: chain steps, combine results and handle errors.

Virtual threads are lightweight threads scheduled by the JVM, not the OS (Project Loom, final in Java 21). Millions can exist. A blocking call such as I/O parks the virtual thread and frees its carrier platform thread.

Both are reentrant mutual-exclusion locks. ReentrantLock adds control that synchronized lacks.

Use @RestControllerAdvice with @ExceptionHandler methods to turn exceptions into consistent error responses, ideally RFC 7807 ProblemDetail (Spring 6).

Lazy loading fetches an association only when it is first accessed. Eager loading fetches it immediately with the parent.

The simplest safe options are an enum singleton or the initialization-on-demand holder idiom.

map transforms each element into one element. flatMap transforms each element into a stream and flattens them into one stream.

Boot loads application.properties or application.yml, then profile files such as application-prod.yml, environment variables and command-line arguments. Later sources override earlier ones, so env vars win over files.

Test the smallest slice that proves the behaviour.

Parallel gives the most throughput but has stop-the-world pauses. G1 balances pause times and throughput. ZGC aims for very short pauses whatever the heap size.

Capture evidence, find what is retaining memory, fix it, and add a guard.

Measure before changing anything, and narrow down from the outside in.

count++ is not atomic (read, add, write), so threads overwrite each other's updates. This is a race condition.

The most likely cause is a key whose hashCode or equals changed after it was added, or a broken hashCode/equals pair.

It happens when a collection is structurally modified during iteration by anything other than the iterator itself. The fail-fast iterator compares a modCount and throws.

Enable caching with @EnableCaching and annotate methods. Back it with Caffeine for in-process or Redis for shared caches.

Never return unbounded lists. Accept page, size and sort parameters, validate them, and return a page with metadata.

Read the failure analysis: it names the missing bean and the injection point.