DEVPREP CODEX · #10

Java Interview Questions

171 curated questions graded from Foundations (Easy) to Practical Patterns (Medium) and Internals & Architecture (Hard).

TOTAL QUESTIONS

171

THEORY QUESTIONS

150

IMPLEMENTATION FOLIOS

FREE QUESTIONS

5 / Level

Easy Level·57 Questions Total

Foundations & Core Concepts

Open Full Easy List

Q1What is Java? Why is it considered platform-independent?

Java: A high-level, class-based, object-oriented programming language.
Platform Independence: Java uses a "Write Once, Run Anywhere" (WORA) model. The Java compiler (javac) converts source code (.java) into intermediate bytecode (.class). The Java Virtual Machine (JVM) interprets or compiles this bytecode into native machine code specific to the host operating system.

Q2Explain the differences between JDK, JRE, and JVM.

JVM (Java Virtual Machine): The execution engine that runs Java bytecode on the host OS.
JRE (Java Runtime Environment): JVM + Libraries + core files required to run compiled Java applications.
JDK (Java Development Kit): JRE + Development Tools (compiler javac, debugger jdb, packager).

Q3What is the JIT Compiler and how does it work?

JIT (Just-In-Time) Compiler: A component of the JVM's execution engine.
Mechanism: Instead of interpreting bytecode line-by-line repeatedly, JIT compiles frequently executed code blocks ("hotspots") directly into native machine code at runtime, caching it for subsequent executions to boost performance.

Q4List the primitive data types in Java, their sizes, and default values.

byte: 1 byte, default 0.
short: 2 bytes, default 0.
int: 4 bytes, default 0.
long: 8 bytes, default 0L.
float: 4 bytes, default 0.0f.
double: 8 bytes, default 0.0d.
char: 2 bytes (Unicode), default '\u0000'.
boolean: JVM-dependent (effectively 1 bit/byte), default false.

Q5Explain the concept of Autoboxing and Unboxing.

Autoboxing: Automatic conversion of primitive types to their corresponding wrapper classes by the Java compiler (e.g., int to Integer).
Unboxing: The reverse process—automatic conversion of wrapper class instances back into primitive types (e.g., Double to double).

52 More Easy Questions Locked

Unlock the complete Java Easy question bank

Get instant access to all 57 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Medium Level·57 Questions Total

Mechanisms & Practical Patterns

Open Full Medium List

Q1What is the difference between fail-fast and fail-safe iterators?

Fail-Fast:
- Mechanism: Operates directly on the collection's structure. If the collection is structurally modified (added/removed) after the iterator is created, it immediately throws ConcurrentModificationException using a modCount check.
- Examples: ArrayList, HashMap, HashSet iterators.
Fail-Safe (Weakly Consistent):
- Mechanism: Operates on a clone or snapshot of the collection, or utilizes lock-free concurrent structures. It does not throw exceptions if modifications occur during iteration.
- Examples: CopyOnWriteArrayList, ConcurrentHashMap iterators.

Q2Explain how ConcurrentHashMap achieves high concurrency in Java 8.

Locking Mechanism: Instead of locking the entire map (like Hashtable or Collections.synchronizedMap), it uses Node-level synchronization using CAS (Compare-And-Swap) for empty buckets and locks only the head node of a specific bucket segment during write operations.
Concurrency Level: Allows concurrent read operations without locking and locks individual buckets during writes, enabling high throughput under heavy multithreaded loads.

Q3Explain the difference between ExecutorService.submit() and execute().

execute(): Defined in the Executor interface. Accepts a Runnable task, returns void (fire-and-forget), and propagates unhandled exceptions directly to the thread's uncaught exception handler.
submit(): Defined in ExecutorService. Accepts Runnable or Callable tasks, returns a Future object wrapping the execution state, and swallows exceptions, returning them inside the Future.get() call.

Q4Detail the parameters of ThreadPoolExecutor.

corePoolSize: The minimum number of threads kept alive in the pool, even if they are idle.
maximumPoolSize: The maximum number of active threads allowed to run concurrently in the pool.
keepAliveTime: The maximum duration that excess idle threads (beyond core size) wait for new tasks before terminating.
workQueue: The queue (BlockingQueue) holding tasks before they are picked up by active threads (e.g., LinkedBlockingQueue, SynchronousQueue).

Q5What are the different types of thread pools created by the Executors utility?

Fixed Thread Pool (newFixedThreadPool(n)): Uses a fixed number of threads and an unbounded queue.
Cached Thread Pool (newCachedThreadPool()): Spawns new threads dynamically as needed, reclaiming idle threads after 60 seconds; uses a SynchronousQueue (no storage capacity).
Single Thread Executor (newSingleThreadExecutor()): Spawns exactly one worker thread executing tasks sequentially in FIFO order.
Scheduled Thread Pool (newScheduledThreadPool(n)): Scheduled to execute commands after a delay or periodically.

52 More Medium Questions Locked

Unlock the complete Java Medium question bank

Get instant access to all 57 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Hard Level·57 Questions Total

Internals & System Architecture

Open Full Hard List

Q1Detail the lifecycle of HotSpot JVM thread synchronization locks (Lock Inflation).

Mark Word: An object's memory header contains a "Mark Word" storing locking state bits.
Stage 1: Biased Locking (Deprecated/Removed): Thread ID is written into the Mark Word. Subsequent locking attempts by the same thread skip synchronization operations completely.
Stage 2: Lightweight Locking: If another thread attempts acquisition, the lock inflates to lightweight. The JVM uses CAS to copy the Mark Word to the lock-seeking thread's stack. If it succeeds, the lock is acquired. If contention occurs, the thread spins briefly.
Stage 3: Heavyweight Locking (Inflated): If contention persists, the lock inflates to heavyweight. The Mark Word is rewritten to point to an OS-level monitor (ObjectMonitor). Threads are parked and queued in native OS wait states, incurring heavy kernel context-switching penalties.

Q2Compare JVM Garbage Collection algorithms: Serial, Parallel, G1, ZGC, and Shenandoah.

Serial GC: Single-threaded; pauses all application threads ("Stop-the-World"/STW) for both young and old collections. Ideal for tiny memory footprints.
Parallel GC: Multi-threaded young and old collection. High throughput, but causes significant STW pauses.
G1 (Garbage-First) GC: Divides the heap into equal region blocks. It targets regions containing the most garbage first, performing incremental, concurrent collections to meet configurable maximum pause times (-XX:MaxGCPauseMillis).
ZGC: A scalable, low-latency concurrent collector using colored pointers (storing metadata in reference bits) and load barriers (intercepting references to update object coordinates on-the-fly). STW pauses are sub-millisecond, independent of heap scale (supports terabytes).
Shenandoah: Similar to ZGC, uses concurrent evacuation barriers to compact the heap concurrently, minimizing pause times.

Q3Explain memory barriers and compilation instruction reordering under the JMM.

Instruction Reordering: Compilers, JVM, and CPU architectures reorder execution instructions to maximize pipelining and cache efficiency, provided single-thread execution outcomes remain unchanged.
Memory Barriers (Fences): Hard CPU instructions inserted by the JVM to enforce memory ordering:
- LoadLoad: Prevents subsequent reads from reordering before previous reads.
- StoreStore: Prevents subsequent writes from reordering before previous writes.
- LoadStore: Prevents subsequent writes from reordering before previous reads.
- StoreLoad: The strongest fence; forces all previous writes to main memory before subsequent reads are evaluated.

Q4Detail Classloading resolution, initializing sequences, and Class.forName() vs ClassLoader.loadClass().

Execution order:
1. Loading: Reads bytecode binary streams.
2. Linking: Verifies bytecode structure, prepares static fields with default values, and optionally resolves symbolic references.
3. Initialization: Executes static initializer blocks (static {}) and assigns real values to static fields.
Class.forName("MyClass"): Loads, links, and initializes the class, running static blocks immediately.
ClassLoader.loadClass("MyClass"): Only loads the class; linking and initialization are delayed until the class is instantiated or referenced.

Q5How do you trace and diagnose memory leaks, thread starvation, and CPU spikes?

Memory Leaks: Generate heap dumps using jmap -dump:live,format=b,file=heap.hprof [pid]. Analyze references using Eclipse Memory Analyzer (MAT) to identify leak suspects retaining massive heaps (retained size).
Thread Starvation/Deadlocks: Generate thread dumps using jstack [pid] or jcmd [pid] Thread.print. Examine thread states to locate deadlocks or threads blocked indefinitely on monitor lock acquisitions.
CPU Spikes: Profile CPU hot paths using async-profiler or JProfiler to capture on-cpu stack traces, identifying performance-intensive methods and loop bottlenecks.