Java Interview Questions and Answers (2026)

== compares references (are these the same object?). .equals() compares logical value, if the class overrides it. Always override hashCode() whenever you override equals() so the object behaves correctly in hash-based collections.

final marks a variable, method or class as non-reassignable, non-overridable or non-extendable. finally is a block that always runs after try/catch, used for cleanup. finalize() was a method the GC could call before collecting an object; it is deprecated and should not be used — use try-with-resources or Cleaner instead.

An abstract class can hold state and constructors and models an "is-a" relationship with shared implementation. An interface is a contract; since Java 8 it can have default and static methods but no instance state. A class extends one abstract class but can implement many interfaces.

Checked exceptions (subclasses of Exception but not RuntimeException) must be declared or handled — they represent recoverable conditions. Unchecked exceptions (RuntimeException and subclasses) usually indicate programming errors and are not forced on callers.

Automatic conversion between primitives and their wrapper types. It bites you in performance-sensitive loops (unnecessary object creation), in == comparisons of Integer objects outside the -128..127 cache, and with NullPointerException when unboxing a null wrapper.

Keys are hashed to a bucket index. Each bucket holds entries in a linked list, which converts to a balanced tree once it passes a threshold (8) to keep worst-case lookups at O(log n). On resize the table doubles and entries are rehashed. Good hashCode() and immutable keys are essential.

ArrayList almost always. It has better cache locality and O(1) random access; add/remove at the end is amortised O(1). LinkedList only wins when you do frequent inserts/removals at both ends via the Deque interface, and even then ArrayDeque is usually better.

HashMap has no ordering. LinkedHashMap preserves insertion order (or access order, useful for LRU caches). TreeMap keeps keys sorted and offers range queries, at O(log n) cost.

It is thrown when a collection is structurally modified while being iterated with a fail-fast iterator. Avoid it by using the iterator's own remove(), collecting changes and applying them after the loop, using removeIf, or iterating a concurrent collection.

A process has its own memory space; threads share the heap of their process and have their own stack. Threads are cheaper to create and communicate through shared memory, which is also why synchronisation is needed.

Visibility and ordering: a write to a volatile field is visible to other threads immediately, and it prevents certain instruction reordering around it. It does not provide atomicity for compound actions like count++ — use AtomicInteger or a lock for that.

synchronized is simpler and released automatically. ReentrantLock adds tryLock, interruptible locking, fairness options and multiple condition variables, at the cost of a mandatory try/finally unlock.

Lightweight threads managed by the JVM rather than the OS, so you can have millions of them. They make blocking code scale like async code without the callback style. They are ideal for I/O-bound server workloads; they do not speed up CPU-bound work.

A managed set of reusable worker threads fed by a task queue. It caps concurrency, avoids the cost of creating threads per task, and gives you back-pressure. Use ThreadPoolExecutor (or Executors factory methods, carefully — the unbounded-queue defaults can hide problems).

The GC identifies objects still reachable from GC roots and reclaims the rest. Modern collectors (G1, ZGC, Shenandoah) split work into short concurrent phases to keep pause times low. The generational hypothesis — most objects die young — is why the heap is split into young and old regions.

Watch heap usage over time (if it trends up and never recovers after GC, suspect a leak). Take a heap dump, open it in a tool like Eclipse MAT, look at the dominator tree for large retained sets, and trace the reference chain back to the root holding the memory — often a static collection or an unbounded cache.

Confirm where the time goes: application vs database vs downstream calls. Add timing/tracing, check slow query logs, look at connection-pool saturation and GC pauses, and profile with async-profiler or JFR under load. Fix the biggest contributor first, then re-measure.

Objects declare what they need rather than constructing it, and a container supplies the dependencies. It decouples components, makes them testable (inject mocks), and centralises configuration. Prefer constructor injection so dependencies are explicit and the object is immutable.

Functionally they are all beans. The specific ones carry intent and, in the case of @Repository, translate persistence exceptions; @Controller/@RestController mark web handlers. Use the specific stereotype that matches the role.

On startup Spring Boot inspects the classpath and your beans and conditionally configures things (@ConditionalOnClass, @ConditionalOnMissingBean, etc.). If the H2 driver is present and you have no DataSource, it configures an in-memory one; if you define your own, it backs off. --debug prints the auto-configuration report.

Loading a list of N entities and then triggering one extra query per entity for a lazy association — N+1 queries total. Fix it with a JOIN FETCH, an entity graph, @BatchSize, or a projection that selects exactly what you need.