Oracle Certified Professional Java Developer Interview Preparation Guide

The traditional classpath searches all available jars and directories for classes in a flat, unstructured manner, which can lead to split packages and unpredictable classpath collision errors. The module path, introduced in Java 9 with the Java Platform Module System (JPMS), enforces strict encapsulation boundaries, explicit dependency declarations via module-info.java, and reliable configuration checks at startup. On the module path, split packages (where two modules contain classes in the same package) are strictly prohibited and cause compilation or layer initialization failures, ensuring deterministic and secure application loading.

Platform threads are thin wrappers around operating system kernel threads, making them expensive to create and maintain in large quantities (limited to thousands per JVM). Virtual threads are lightweight, user-mode threads managed entirely by the Java runtime, allowing millions of concurrent instances with minimal memory overhead. You should use virtual threads for I/O-bound tasks—such as HTTP clients, database queries, and socket servers—where threads spend most of their time waiting. Platform threads should be reserved for long-running CPU-bound workloads or when interacting with native code that pins carrier threads.

Pinning occurs when a virtual thread executes inside a synchronized block/method or performs a native method invocation/foreign function call. When pinned, the underlying carrier thread cannot be unmounted to execute other virtual threads, effectively defeating the scalability benefits of virtual threads. You can prevent pinning by replacing traditional synchronized blocks with ReentrantLock or other java.util.concurrent locking primitives, which do not pin virtual threads during blocking operations.

The G1 garbage collector is a generational collector that divides the heap into equal-sized regions and manages pause times by collecting regions with the most garbage first, though it still experiences stop-the-world pauses during full collections. Traditional ZGC is a scalable, low-latency garbage collector that performs most work concurrently with application threads, keeping pause times under a millisecond regardless of heap size, but historically lacked generational collection. Generational ZGC combines low-latency concurrent marking with generational hypothesis tracking (collecting young objects more frequently), significantly reducing CPU overhead and allocation stalls on large enterprise heaps.

ThreadLocal variables allow storing state tied to a specific thread, but in virtual thread environments with millions of threads, ThreadLocal usage can lead to excessive memory consumption and subtle bugs because values remain accessible indefinitely unless explicitly removed. ScopedValues, introduced as part of project Loom, provide immutable, thread-confined data sharing over a bounded execution scope (such as a try-with-resources block). They are significantly more memory-efficient and prevent accidental data leakage across asynchronous task boundaries.

The jlink tool is a command-line utility that takes a set of modules (including application modules and required JDK modules) and assembles them into a custom, optimized runtime image. This image contains only the exact modules needed to run the application, stripping away unused JDK components and reducing container footprint and startup latency. jlink relies entirely on the explicit dependency metadata declared in JPMS module descriptors (module-info.java) to construct this self-contained distribution.

Intermediate operations—such as filter, map, and peek—are lazy; they do not process data immediately when called. Instead, they return a new stream representing a further stage in the processing pipeline. Terminal operations—such as collect, reduce, count, and forEach—are eager; they trigger the execution of the entire stream pipeline, process the data through the intermediate steps, and produce a final result or side-effect. No operations are executed on stream elements until a terminal operation is invoked.

A standard ReentrantReadWriteLock provides exclusive write locks and shared read locks, but reader threads can block writers and vice versa under high contention. StampedLock introduces an optimistic read mode that does not acquire a formal lock, returning a validation stamp instead. The reading thread then accesses shared state and subsequently validates whether a write lock was acquired in the interim; if validation fails, the reader falls back to a standard read lock. This significantly improves read-heavy performance by avoiding memory synchronization overhead.

Record classes are a special kind of class introduced to model immutable data carriers with minimal boilerplate syntax. When you declare a record, the compiler automatically generates a private final field for each component, a canonical constructor, public accessor methods, and proper implementations of equals, hashCode, and toString. Immutability is enforced because component fields cannot be reassigned after construction and default constructors are private final, though developers must ensure referenced mutable objects inside records are defensively copied.

Prior to JPMS, any application or library could use setAccessible(true) via reflection to access private fields and internal classes across any package in the JDK or third-party libraries. JPMS enforces strong encapsulation: internal packages that are not explicitly exported by a module cannot be accessed or reflected upon by code outside that module unless the target module explicitly opens the package using the 'opens' directive. This prevents malicious or accidental tampering with internal APIs and enhances runtime security.