Java Programming Practice Exam

Question 1 Java Programming

What is the difference between thenApply() and thenCompose() in CompletableFuture?

thenApply() takes a Function<T, U> and returns CompletableFuture — transforms a value when the future completes (analogous to map()).
thenCompose() takes a Function<T, CompletionStage> and flattens the result, avoiding CompletableFuture<CompletableFuture> (analogous to flatMap()).
Use thenCompose() whenever the next step itself returns a future (chaining async calls). Use thenApply() for synchronous value transformations. Fail-fast iterators (default for most java.util collections like ArrayList, HashMap) detect concurrent modification via a modCount check and throw ConcurrentModificationException on next iteration after structural change. They are weakly consistent only on the surface — strictly not safe for concurrent mutation.
Fail-safe / weakly consistent iterators (concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList) operate on a snapshot or with weak ordering; they do not throw on concurrent modification and never see modified elements retroactively.

String – immutable, thread-safe, stored in String Pool
StringBuilder – mutable, not thread-safe, faster for single-threaded string manipulation
StringBuffer – mutable, thread-safe (synchronized methods), slower than StringBuilder

Use StringBuilder when performance matters in a single thread. Spliterator ("split iterator") is the internal traversal mechanism behind Streams. It can partition a source into sub-sources, supports parallel processing, and reports characteristics via characteristics() (e.g. ORDERED, DISTINCT, SORTED, SIZED, IMMUTABLE).
Most developers never implement one directly, but understanding it explains why some streams parallelize well and others do not.

Question 2 Java Programming

What is a Spliterator in Java?

The Iterator interface provides a way to traverse a collection sequentially.
Methods:

hasNext() – returns true if more elements exist
next() – returns the next element
remove() – removes the last returned element

Use it to safely remove elements during iteration, unlike a for-each loop. The Java Platform Module System (Project Jigsaw) groups packages into modules declared in module-info.java:

module com.example.app {
  requires java.sql;
  exports com.example.api;
  opens com.example.model to com.fasterxml.jackson;
}

requires = dependency; exports = public API; opens = reflective access for libraries like Spring/JPA. requires transitive re-exports a dependency. Modules enable reliable configuration, strong encapsulation, and a smaller custom runtime image via jlink. Spliterator ("split iterator") is the internal traversal mechanism behind Streams. It can partition a source into sub-sources, supports parallel processing, and reports characteristics via characteristics() (e.g. ORDERED, DISTINCT, SORTED, SIZED, IMMUTABLE).
Most developers never implement one directly, but understanding it explains why some streams parallelize well and others do not. • Runnable — no args, no return, can throw any Exception. void run().
• Supplier<T> — no args, returns T, no checked exceptions. T get().
• Callable<V> — no args, returns V, can throw checked Exception. V call().
Use Runnable for fire-and-forget tasks; Supplier for lazy value generation; Callable for asynchronous tasks that return a result or throw checked exceptions.

Question 3 Java Programming

What is the NIO ByteBuffer and what are heap vs direct buffers?

• Parallel GC — throughput-oriented, stop-the-world, full GC pauses; good for batch workloads.
• G1 GC (default since Java 9) — regional, mostly-concurrent, balances throughput and latency; target -XX:MaxGCPauseMillis.
• ZGC (Java 11+) — sub-millisecond pauses regardless of heap size, concurrent; great for very large heaps (multi-GB to TB) and latency-sensitive services.
• Shenandoah — similar to ZGC, low-pause concurrent collector.
Pick by SLA: ZGC/Shenandoah for <10 ms pauses, G1 for balanced, Parallel for batch. ByteBuffer (java.nio) is a fixed-size container for binary data. Two allocation modes:
• Heap: ByteBuffer.allocate(n) — backed by a byte[] on the JVM heap; GC-managed, fast to allocate, but requires a copy when passed to native channels.
• Direct: ByteBuffer.allocateDirect(n) — allocated outside the heap; native code (channels, sockets) can read/write without copying, ideal for high-throughput I/O. Direct buffers are more expensive to allocate and freed via Cleaner, not GC. Interpreted — the JVM walks bytecode one instruction at a time; fast to start, slow steady-state.
JIT-compiled (C1/C2/Graal) — the HotSpot compiler profiles hot methods and compiles them to native code; slow startup, fast steady-state. Tiered compilation blends both.
AOT (Ahead-of-Time) (GraalVM Native Image) — compiles to a native binary before run time; near-instant startup, low memory, slower peak CPU, less reflection friendly.
Modern JVMs use a mix: C1 + C2 tiered compilation, with AOT via Graal for cloud/serverless. Object.finalize() is called by the GC at most once on an object before it is reclaimed, but the timing is not guaranteed and in practice many objects may never be finalized.
Drawbacks: unpredictable, can resurrect the object by assigning a new reference, slow, and can cause GC pauses. Deprecated for removal since Java 9.
Use try-with-resources + AutoCloseable for deterministic cleanup, or java.lang.ref.Cleaner (Java 9+) for off-heap resource cleanup.

Question 4 Java Programming

What are the SOLID principles in Java OOP?

Fail-fast iterators (default for most java.util collections like ArrayList, HashMap) detect concurrent modification via a modCount check and throw ConcurrentModificationException on next iteration after structural change. They are weakly consistent only on the surface — strictly not safe for concurrent mutation.
Fail-safe / weakly consistent iterators (concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList) operate on a snapshot or with weak ordering; they do not throw on concurrent modification and never see modified elements retroactively. Fork/Join (Java 7+) is a framework for parallelizing divide-and-conquer tasks. It uses a work-stealing ForkJoinPool: idle threads steal tasks from busy threads' deques, balancing load.
Tasks extend RecursiveTask<V> (returns a result) or RecursiveAction (no result) and implement compute(), calling fork() on subtasks and join() to collect results. parallelStream() uses the common pool by default; configure parallelism with System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "N"). SOLID = five design principles:
• Single Responsibility: a class has one reason to change.
• Open/Closed: open for extension, closed for modification.
• Liskov Substitution: subtypes must be substitutable for their base types.
• Interface Segregation: prefer many small interfaces over one fat interface.
• Dependency Inversion: depend on abstractions, not concretions.
They guide maintainable, testable object-oriented design. The Java Virtual Machine (JVM) is an abstract computing machine that executes Java bytecode. It provides platform independence by translating bytecode into native machine instructions at runtime, enabling the "Write Once, Run Anywhere" principle.

Question 5 Java Programming

What is a functional interface with a default method — does it remain functional?

ServiceLoader implements the Service Provider Interface (SPI) pattern using META-INF/services/ files or module provides ... with ... directives. It lazily discovers and instantiates implementations of an interface at runtime.
Example:

ServiceLoader<Driver> sl = ServiceLoader.load(Driver.class);
for (Driver d : sl) d.connect(...);

JDBC, LoggerFinder, ImageIO, and many Java SE subsystems use ServiceLoader for pluggable implementations. super refers to the parent class. It is used to:

Call the parent constructor: super(args);
Access parent methods: super.methodName();
Access parent fields hidden by child fields

ArrayList: backed by a dynamic array. Fast O(1) random access via index. Slow O(n) insertions/deletions in the middle.
LinkedList: backed by a doubly-linked list. Fast O(1) insertions/deletions at head/tail. Slow O(n) random access. Also implements Deque. Yes. A functional interface must have exactly one abstract method (SAM). Default and static methods, and methods inherited from Object, do not count toward the SAM count.
Example: Predicate<T> has one abstract method test(T) plus a default and(...) and a static isEqual(...), yet it is still a functional interface.

Question 6 Java Programming

What are lambda expressions in Java?

List<? extends T> — a list of some unknown subtype of T. Safe to read as T, but you cannot add (except null) because the actual type is unknown.
List<? super T> — a list of some unknown supertype of T. Safe to add T (and its subtypes), but reading returns Object.
Together they support variance: covariance for producers, contravariance for consumers. Strategy defines a family of algorithms, encapsulates each one, and makes them interchangeable. Each strategy is a class implementing a common interface; the context object delegates work to the strategy instance.
Example: interface PricingStrategy { double price(double base); } with RegularPricing, DiscountPricing, HolidayPricing implementations. Combined with lambdas, the pattern reduces to passing a function — but the explicit interface remains useful when state/configuration is involved. Lambda expressions (Java 8+) provide a concise way to implement functional interfaces (interfaces with a single abstract method).
Syntax: (parameters) -> expression
Example: List.sort((a, b) -> a.compareTo(b));
They enable functional programming and are heavily used with the Streams API. ConcurrentHashMap is a thread-safe map with fine-grained locking / lock-free reads (Java 8+ uses CAS + synchronized per bucket, no global lock). It allows concurrent reads and a high degree of concurrent writes, and weakly consistent iterators that do not throw ConcurrentModificationException.
Hashtable locks the entire map on every operation → poor scalability under contention. ConcurrentHashMap forbids null keys and values; Hashtable also forbids nulls. Prefer ConcurrentHashMap for concurrent maps.

Question 7 Java Programming

What is the difference between HashMap and TreeMap?

Java 11 added Predicate.not(p) as a static factory equivalent to p.negate() but more useful with method references:
list.removeIf(Predicate.not(String::isBlank)); is clearer than list.removeIf(s -> !s.isBlank());.
It is also a workaround for overload resolution ambiguity: passing a method reference to an IntPredicate/Predicate overload that is otherwise ambiguous. transient (storage modifier): a field marked transient is excluded from default Serializable serialization. Useful for non-serializable state, derived values, or sensitive data.
volatile (visibility modifier): a field marked volatile is read/written directly to main memory, providing cross-thread visibility.
They are unrelated — transient concerns persistence; volatile concerns concurrency. Both are applied to fields, not methods. LSP states that objects of a superclass must be replaceable with objects of a subclass without breaking behavior.
Classic violation: Rectangle superclass with setWidth/setHeight; Square subclass overrides both to keep sides equal, so a method expecting a Rectangle that calls both setters gets an unexpected area. Fix: prefer composition, or design immutable value types, or split roles into separate abstractions. HashMap: stores key-value pairs in a hash table. O(1) average lookup. No ordering of keys. Allows one null key.
TreeMap: stores entries in a red-black tree. O(log n) lookup. Keys are sorted in natural order or by a custom Comparator. Does not allow null keys.

Question 8 Java Programming

How do you create a custom exception in Java?

Multithreading allows concurrent execution of two or more threads. Create threads by:

Extending Thread class and overriding run()
Implementing Runnable interface
Using ExecutorService (preferred)

Start a thread with thread.start(), not thread.run(). HashSet: uses a hash table internally. O(1) add/remove/contains. No ordering guarantee. Allows one null.
TreeSet: uses a red-black tree. O(log n) operations. Elements are stored in sorted order. Does not allow null. Implements NavigableSet. Stack — per-thread LIFO of stack frames for active method calls. Stores local variables (primitives + references), operand stack, return address. Allocation is fast and automatic; freed on method return. Size: -Xss.
Heap — shared region for all objects and class metadata. Garbage-collected, sized via -Xms/-Xmx. Generational: Eden + Survivor + Old (Tenured). Large arrays or objects may go directly to Old. Create a class that extends Exception (checked) or RuntimeException (unchecked):

public class InsufficientFundsException extends Exception {
  public InsufficientFundsException(String message) {
    super(message);
  }
}

Throw it with: throw new InsufficientFundsException("Balance too low");

Question 9 Java Programming

What is the difference between the stack and heap memory in the JVM?

Stack — per-thread LIFO of stack frames for active method calls. Stores local variables (primitives + references), operand stack, return address. Allocation is fast and automatic; freed on method return. Size: -Xss.
Heap — shared region for all objects and class metadata. Garbage-collected, sized via -Xms/-Xmx. Generational: Eden + Survivor + Old (Tenured). Large arrays or objects may go directly to Old. CompletableFuture<T> implements Future<T> and CompletionStage<T>, supporting composable, asynchronous pipelines.
Key methods:
• supplyAsync(() -> value) / runAsync(runnable).
• thenApply(), thenAccept(), thenRun() — chain transformations.
• thenCompose() — flatten a nested future (like flatMap).
• thenCombine() — combine two independent futures.
• exceptionally() / handle() — recover from errors.
• allOf() / anyOf() — aggregate multiple futures.
By default uses the common ForkJoinPool; pass a custom Executor for control. Classes in java.util.concurrent.atomic providing lock-free, thread-safe operations on single variables using low-level CAS (compare-and-swap) CPU instructions.
Key methods: incrementAndGet(), getAndIncrement(), compareAndSet(expected, new), updateAndGet(), and Java 8+ accumulateAndGet() / getAndAccumulate().
Use them for counters and flags; they outperform synchronized for low-to-moderate contention. Combine with AtomicReference for non-blocking stacks and queues. If the stream produces duplicate keys, Collectors.toMap(keyMapper, valueMapper) throws IllegalStateException: Duplicate key.
Fix: provide a merge function:

stream().collect(Collectors.toMap(
  Person::getId,
  Person::getName,
  (a, b) -> a + "," + b));

For order preservation use Collectors.toMap(..., LinkedHashMap::new); to allow null values use Collectors.toUnmodifiableMap variants carefully — some throw on null keys/values.

Question 10 Java Programming

What is a sealed class in Java (since Java 17)?

Switch expressions use arrow syntax and return a value:

String label = switch (day) {
  case MONDAY, FRIDAY, SUNDAY -> "fun";
  case TUESDAY -> "meh";
  default -> "other";
};

Exhaustiveness is checked for enum switches — if all cases are covered, no default is required. Combined with sealed types, the compiler can prove all cases handled. Replaces verbose break;-laden switch statements. StampedLock (in java.util.concurrent.locks) supports three modes:
• Write lock — exclusive.
• Read lock — shared.
• Optimistic read — a non-blocking stamp; later validate the stamp with validate(stamp) and re-read if invalid.
Optimistic reads are extremely fast for read-mostly data because they avoid CAS. StampedLock is not reentrant and has no notion of ownership; the same thread reentering a write lock it already holds can deadlock. A sealed class restricts which other classes may extend it. The compiler enforces the closed hierarchy, enabling exhaustive pattern matching in switch.
Example:

public sealed class Shape permits Circle, Square, Triangle { }
public final class Circle extends Shape { }
public final class Square extends Shape { }
public non-sealed class Triangle extends Shape { }

Permitted subclasses must be in the same module/package and declared final, sealed, or non-sealed. Replaces ad-hoc "package-private" or "check by string" hierarchies. final has three uses:

Variable: value cannot be changed (constant)
Method: cannot be overridden by subclasses
Class: cannot be extended

Example: final int MAX = 100;

Question 11 Java Programming

What is the difference between Predicate.not() and explicit negation?

Java 11 added Predicate.not(p) as a static factory equivalent to p.negate() but more useful with method references:
list.removeIf(Predicate.not(String::isBlank)); is clearer than list.removeIf(s -> !s.isBlank());.
It is also a workaround for overload resolution ambiguity: passing a method reference to an IntPredicate/Predicate overload that is otherwise ambiguous. map(Function) — returns Stream<R> for any R; no special numeric operations.
mapToInt(ToIntFunction) — returns IntStream, an autoboxing-free primitive stream. Provides sum(), average(), summaryStatistics(), range() factories, and is generally faster for numeric pipelines.
Similar mapToLong / mapToDouble variants exist. Convert back to object stream with boxed(). getOrDefault(key, default) — returns the value if present, else the supplied default; does not modify the map.
putIfAbsent(key, value) — sets and returns the value if absent; if present, returns the existing value and does not modify. Atomic on ConcurrentHashMap.
Use getOrDefault for read-only fallback; use putIfAbsent for cache fill. For "compute the value only if missing", use computeIfAbsent — it accepts a lambda to avoid unnecessary computation. Multithreading allows concurrent execution of two or more threads. Create threads by:

Extending Thread class and overriding run()
Implementing Runnable interface
Using ExecutorService (preferred)

Start a thread with thread.start(), not thread.run().

Question 12 Java Programming

What are annotations in Java?

Annotations provide metadata about the code. They do not directly affect execution but can be processed at compile time or runtime.
Common annotations:

@Override – method overrides a superclass method
@Deprecated – marks code as obsolete
@SuppressWarnings – suppresses compiler warnings
@FunctionalInterface – validates single abstract method

You can bind the matched object to a variable directly:

if (obj instanceof String s) {
  System.out.println(s.length());
}

The variable s is in scope only where the type is known to be String. Eliminates the traditional cast + temporary variable pattern. Combined with switch patterns (Java 21+), it enables exhaustive type-based dispatch on sealed hierarchies. Builder separates the construction of a complex object from its representation, allowing step-by-step configuration. Useful when an object has many optional parameters or telescoping constructors become unreadable.
Example: new User.Builder("Alice").age(30).email("a@b.com").admin(true).build();
Lombok's @Builder and Java 16+ records reduce boilerplate. Effective Java Item 2 strongly recommends builders over constructors for many-parameter classes. Stack — per-thread LIFO of stack frames for active method calls. Stores local variables (primitives + references), operand stack, return address. Allocation is fast and automatic; freed on method return. Size: -Xss.
Heap — shared region for all objects and class metadata. Garbage-collected, sized via -Xms/-Xmx. Generational: Eden + Survivor + Old (Tenured). Large arrays or objects may go directly to Old.

Question 13 Java Programming

What is the strategy pattern in Java?

Strategy defines a family of algorithms, encapsulates each one, and makes them interchangeable. Each strategy is a class implementing a common interface; the context object delegates work to the strategy instance.
Example: interface PricingStrategy { double price(double base); } with RegularPricing, DiscountPricing, HolidayPricing implementations. Combined with lambdas, the pattern reduces to passing a function — but the explicit interface remains useful when state/configuration is involved. Comparator<T> defines a custom ordering separate from the object's class.
Example: Comparator<Student> byAge = (a, b) -> Integer.compare(a.getAge(), b.getAge());
Useful when you need multiple sorting strategies or cannot modify the class. Chain comparators with .thenComparing(). var lets the compiler infer the type of a local variable from its initializer: var list = new ArrayList<String>();
Restrictions:
• Only for local variables (with initializer), for loop indices, and lambda parameters (Java 11+).
• Not allowed for fields, method parameters, or return types.
• Type is fixed at compile time; reassignment must be to compatible types.
• Avoid var when the right-hand side is non-obvious (e.g. var x = method();) — readability suffers. PECS — when writing a method that consumes or produces generic values:
• If you only read from a collection (it's a producer), use ? extends T.
• If you only write into a collection (it's a consumer), use ? super T.
Example: void copy(List<? extends T> src, List<? super T> dest) — read from src, write to dest.
Mnemonic: "Get and Put" = extends in the "get" (producer) position, super in the "put" (consumer) position.

Question 14 Java Programming

What is the difference between JDK, JRE, and JVM?

• CountDownLatch: N threads count down, 1+ threads wait; single use.
• CyclicBarrier: N threads wait for each other at a barrier, then all proceed; reusable; supports a barrier action.
• Phaser: a flexible phased barrier with dynamic party count; parties register/deregister across phases; useful for staged parallel algorithms where participants come and go.
Choose the simplest that fits: CountDownLatch for one-shot coordination, CyclicBarrier for fixed-size teams, Phaser for evolving groups.

Encapsulation – bundling data and methods, restricting direct access
Inheritance – a class derives from another class
Polymorphism – one interface, many implementations
Abstraction – hiding complex details, showing only essentials

JDK (Java Development Kit) includes tools for developing Java programs.
JRE (Java Runtime Environment) provides libraries and JVM to run Java applications.
JVM (Java Virtual Machine) executes the bytecode. Relationship: JDK ⊃ JRE ⊃ JVM. Interpreted — the JVM walks bytecode one instruction at a time; fast to start, slow steady-state.
JIT-compiled (C1/C2/Graal) — the HotSpot compiler profiles hot methods and compiles them to native code; slow startup, fast steady-state. Tiered compilation blends both.
AOT (Ahead-of-Time) (GraalVM Native Image) — compiles to a native binary before run time; near-instant startup, low memory, slower peak CPU, less reflection friendly.
Modern JVMs use a mix: C1 + C2 tiered compilation, with AOT via Graal for cloud/serverless.

Question 15 Java Programming

What is the Observer pattern in Java?

Observer defines a one-to-many dependency so that when one object (the subject) changes state, all its dependents (observers) are notified.
Pre-9: java.util.Observer / Observable — deprecated.
Modern Java: implement your own interface (addListener, removeListener, fireEvent), or use PropertyChangeListener / PropertyChangeSupport (in java.beans), or use Flow API (Reactive Streams) for backpressure-aware streams.
Libraries: RxJava, Reactor, Guava EventBus. Create a class that extends Exception (checked) or RuntimeException (unchecked):

public class InsufficientFundsException extends Exception {
  public InsufficientFundsException(String message) {
    super(message);
  }
}

Throw it with: throw new InsufficientFundsException("Balance too low"); String.join(delim, elements) concatenates an iterable/array of strings with the given delimiter: String.join(", ", "a", "b", "c"); → "a, b, c".
StringJoiner is a mutable builder for the same idea with prefix/suffix: new StringJoiner(", ", "[", "]").
Both are convenient for one-shot joins. For repeated building use StringBuilder or Collectors.joining(...) in Streams. Strong — normal Object o = new Object(); prevents GC as long as reachable.
Soft — SoftReference; cleared by GC only when memory is needed (heap-pressure sensitive). Used for memory-sensitive caches.
Weak — WeakReference; cleared at the next GC cycle. Used by WeakHashMap to auto-evict entries when keys are no longer strongly reachable.
Phantom — PhantomReference; enqueued after the object is finalized, before its memory is reclaimed. Used to schedule post-mortem cleanup actions.
Only soft and weak are typically used directly; phantoms are advanced.

Question 16 Java Programming

What is BlockingQueue and what are common implementations?

Encapsulation is the practice of keeping fields private and providing access through public getter and setter methods. This protects the internal state of an object and enforces data hiding.
Example: private int age; public int getAge() { return age; } BlockingQueue is a thread-safe queue whose put()/take() block when the queue is full/empty. It is the standard building block for the producer-consumer pattern.
Common implementations:
• ArrayBlockingQueue — bounded, array-backed.
• LinkedBlockingQueue — optionally bounded, linked nodes.
• PriorityBlockingQueue — unbounded, ordered.
• SynchronousQueue — zero capacity, hands off directly between threads.
• DelayQueue — elements become available after a delay. Singleton ensures a class has exactly one instance and provides a global access point.
Thread-safe lazy version with double-checked locking:

public class Singleton {
  private static volatile Singleton instance;
  private Singleton() {}
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class) {
        if (instance == null) instance = new Singleton();
      }
    }
    return instance;
  }
}

Alternatives: enum singleton (best — serialization-safe and reflection-safe) or eager init. Optional<T> (Java 8+) is a container that may or may not hold a non-null value. It helps avoid NullPointerException.
Key methods:

Optional.of(value) – wraps a non-null value
Optional.empty() – empty Optional
isPresent(), ifPresent()
orElse(default), orElseThrow()

Question 17 Java Programming

What is the difference between Error and Exception in Java?

Singleton ensures a class has exactly one instance and provides a global access point.
Thread-safe lazy version with double-checked locking:

public class Singleton {
  private static volatile Singleton instance;
  private Singleton() {}
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class) {
        if (instance == null) instance = new Singleton();
      }
    }
    return instance;
  }
}

Alternatives: enum singleton (best — serialization-safe and reflection-safe) or eager init. Modern Map defaults for atomic, conditional updates:
• map.compute(key, (k,v) -> newValue) — always set (or remove) based on key+old value.
• map.computeIfAbsent(key, k -> newValue) — only set if absent; atomic on ConcurrentHashMap; common for memoization and Map<String, List<X>> caches.
• map.computeIfPresent(key, (k,v) -> transformed) — only update if key present.
• map.merge(key, value, remappingFunction) — combine old + new (e.g. add counts).
Prefer these over get-then-put to avoid race conditions and null-handling bugs. Error (e.g. OutOfMemoryError, StackOverflowError, LinkageError) represents fatal, unrecoverable conditions the application should not try to catch. The JVM is usually in an unstable state.
Exception represents conditions applications can reasonably handle (I/O failures, validation, business rules).
Catching Throwable or Error is a code smell — let the JVM report and die, or recover at a coarser level (e.g. restart the worker). peek(Consumer) is an intermediate operation intended for debugging; it executes only when a downstream terminal operation runs, and its behavior is undefined in parallel streams if the action mutates shared state.
forEach(Consumer) is a terminal operation that processes every element and is guaranteed to run.
Rule: do not use peek() for side effects in production code; use it only in debug logs. Use forEach() for side effects.

Question 18 Java Programming

What is the Selector in Java NIO and how does it enable non-blocking I/O?

Selector allows a single thread to multiplex many non-blocking SelectableChannel instances (sockets, pipes). Steps:
1. Open selector: Selector.open().
2. Register channels: channel.register(selector, SelectionKey.OP_READ).
3. Loop: selector.select() returns the count of channels with events.
4. Iterate selectedKeys(), handle READ/WRITE/ACCEPT/CONNECT.
It is the foundation of high-performance servers (Netty, Jetty, gRPC Java). map(Function) — returns Stream<R> for any R; no special numeric operations.
mapToInt(ToIntFunction) — returns IntStream, an autoboxing-free primitive stream. Provides sum(), average(), summaryStatistics(), range() factories, and is generally faster for numeric pipelines.
Similar mapToLong / mapToDouble variants exist. Convert back to object stream with boxed(). • Collections.synchronizedList — wraps any List with coarse-grained locking; simple, slow under contention.
• CopyOnWriteArrayList — wait-free reads, expensive copies on writes; great for listener registries.
• ConcurrentLinkedQueue — non-blocking MPMC queue; best for producer/consumer throughput.
• ArrayDeque + BlockingQueue variants when bounded capacity is needed.
Pick based on read/write ratio and access pattern, not a single rule. • Runnable — no args, no return, can throw any Exception. void run().
• Supplier<T> — no args, returns T, no checked exceptions. T get().
• Callable<V> — no args, returns V, can throw checked Exception. V call().
Use Runnable for fire-and-forget tasks; Supplier for lazy value generation; Callable for asynchronous tasks that return a result or throw checked exceptions.

Question 19 Java Programming

What are Java generics?

int[] — a primitive array; stores raw 32-bit ints contiguously; no autoboxing overhead; cannot be used where Object[] is required.
Integer[] — an array of object references to boxed Integers; each element is a heap-allocated object; works with generics (List<Integer>) and reflection.
For numeric processing, primitive arrays (or libraries like Trove, Eclipse Collections, IntStream) avoid boxing. For collections of arbitrary size in generic code, use wrappers. Cleaner (in java.lang.ref) provides a more predictable, thread-safe alternative to finalize() for cleaning up off-heap resources (e.g. direct buffers, native handles).
Example:

Cleaner cleaner = Cleaner.create();
cleaner.register(obj, new CleaningAction());

When obj becomes unreachable, a daemon thread runs the registered Runnable action. The action must not reference the original object (avoid retaining it). Generics enable types (classes, interfaces, methods) to operate on parameterized types, providing compile-time type safety.
Example: List<String> names = new ArrayList<>();
Benefits: eliminates casting, catches type errors at compile time, and enables reusable code. The Iterator interface provides a way to traverse a collection sequentially.
Methods:

hasNext() – returns true if more elements exist
next() – returns the next element
remove() – removes the last returned element

Use it to safely remove elements during iteration, unlike a for-each loop.

Question 20 Java Programming

What are the eight primitive data types in Java?

Externalizable extends Serializable and gives the class full control over its serialization by implementing writeExternal(ObjectOutput) and readExternal(ObjectInput).
Differences from Serializable:
• A public no-arg constructor is required (used during deserialization).
• You decide exactly which fields to write and how to encode them — can be more efficient and version-tolerant.
• Default constructor can run custom initialization before fields are restored. Java has 8 primitives:
byte (8-bit), short (16-bit), int (32-bit), long (64-bit), float (32-bit), double (64-bit), char (16-bit Unicode), boolean (1-bit).
Primitives are stored on the stack (when local) and have no methods or identity. They are not objects; use wrapper classes (e.g. Integer) when object behavior is required. Runnable: has void run() method. Cannot return a result or throw checked exceptions.
Callable<V>: has V call() method. Can return a value and throw exceptions.
Use Callable with ExecutorService.submit() which returns a Future<V> to retrieve the result asynchronously. ServiceLoader implements the Service Provider Interface (SPI) pattern using META-INF/services/ files or module provides ... with ... directives. It lazily discovers and instantiates implementations of an interface at runtime.
Example:

ServiceLoader<Driver> sl = ServiceLoader.load(Driver.class);
for (Driver d : sl) d.connect(...);

JDBC, LoggerFinder, ImageIO, and many Java SE subsystems use ServiceLoader for pluggable implementations.

Question 21 Java Programming

What is the synchronized keyword?

thenApply() takes a Function<T, U> and returns CompletableFuture — transforms a value when the future completes (analogous to map()).
thenCompose() takes a Function<T, CompletionStage> and flattens the result, avoiding CompletableFuture<CompletableFuture> (analogous to flatMap()).
Use thenCompose() whenever the next step itself returns a future (chaining async calls). Use thenApply() for synchronous value transformations. An exception is an event that disrupts normal program flow. Java's exception hierarchy:
Throwable → Exception (checked) and Error (unchecked, serious).
RuntimeException extends Exception and is unchecked.
Handle with try-catch-finally blocks. Built-in functional interfaces (Supplier, Function, Consumer, Predicate) do not allow checked exceptions. To wrap an I/O throwing method as a lambda, you can:
1. Define your own functional interface with throws Exception.
2. Catch and rethrow as RuntimeException inside the lambda.
3. Use @FunctionalInterface with E extends Throwable generics on a custom interface.
4. Use Lombok's @SneakyThrows (controversial, but concise). synchronized ensures that only one thread can access a block of code or method at a time, preventing race conditions.
Usage:
synchronized void increment() { count++; }
Or as a block: synchronized(lockObject) { // critical section }
It acquires an intrinsic lock (monitor) on the object.

Question 22 Java Programming

What is the Fork/Join framework in Java?

ThreadPoolExecutor is configured with 7 core parameters:
• corePoolSize — minimum threads kept alive.
• maximumPoolSize — upper limit.
• keepAliveTime / unit — idle time before surplus threads die.
• workQueue — holds tasks waiting for a thread.
• threadFactory — creates threads (set names!).
• handler — RejectedExecutionHandler for when the pool and queue are full (e.g. AbortPolicy, CallerRunsPolicy).
Prefer ThreadPoolExecutor over the Executors shortcuts so you can name threads and choose the queue safely. ArrayList: backed by a dynamic array. Fast O(1) random access via index. Slow O(n) insertions/deletions in the middle.
LinkedList: backed by a doubly-linked list. Fast O(1) insertions/deletions at head/tail. Slow O(n) random access. Also implements Deque. Serialization converts an object to a byte stream via ObjectOutputStream / ObjectInputStream. A class opts in by implementing Serializable (a marker). On deserialization the JVM bypasses constructors — fields are populated reflectively. serialVersionUID controls version compatibility.
Pitfalls:
• Constructor bypass breaks invariants.
• Hidden security risks: deserialization gadget chains can execute attacker code (Java 8+ validates ObjectInputFilter to mitigate).
• Brittle to refactoring.
Prefer JSON/Protobuf for cross-system exchange; reserve Serializable for short-lived caches. Fork/Join (Java 7+) is a framework for parallelizing divide-and-conquer tasks. It uses a work-stealing ForkJoinPool: idle threads steal tasks from busy threads' deques, balancing load.
Tasks extend RecursiveTask<V> (returns a result) or RecursiveAction (no result) and implement compute(), calling fork() on subtasks and join() to collect results. parallelStream() uses the common pool by default; configure parallelism with System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "N").

Question 23 Java Programming

What is the difference between ArrayList and LinkedList?

@FunctionalInterface is an informative annotation that tells the compiler to verify the interface has exactly one abstract method. It is not required for an interface to be usable as a lambda target — the compiler treats any SAM type as a functional interface regardless of the annotation.
Always add it to your functional interfaces: it documents intent and prevents future maintainers from accidentally breaking the contract by adding a second abstract method. Checked exceptions must be declared in the method signature with throws or caught with try-catch. Example: IOException.
Unchecked exceptions extend RuntimeException and do not need explicit handling. Example: NullPointerException, ArrayIndexOutOfBoundsException. super refers to the parent class. It is used to:

Call the parent constructor: super(args);
Access parent methods: super.methodName();
Access parent fields hidden by child fields

ArrayList: backed by a dynamic array. Fast O(1) random access via index. Slow O(n) insertions/deletions in the middle.
LinkedList: backed by a doubly-linked list. Fast O(1) insertions/deletions at head/tail. Slow O(n) random access. Also implements Deque.

Question 24 Java Programming

What is a Checked Supplier / Function in functional Java?

reduce(identity, accumulator) — folds the stream into a single value using an associative, ideally stateless binary operator. Example: sum = list.stream().reduce(0, Integer::sum);.
collect(supplier, accumulator, combiner) — accumulates into a mutable container (e.g. StringBuilder, List). The combiner merges partial results, enabling efficient parallel collection.
Use collect when you build a collection; reduce for scalar folds. The 1-arg reduce returning Optional has weaker guarantees in parallel. Fail-fast iterators (default for most java.util collections like ArrayList, HashMap) detect concurrent modification via a modCount check and throw ConcurrentModificationException on next iteration after structural change. They are weakly consistent only on the surface — strictly not safe for concurrent mutation.
Fail-safe / weakly consistent iterators (concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList) operate on a snapshot or with weak ordering; they do not throw on concurrent modification and never see modified elements retroactively. Built-in functional interfaces (Supplier, Function, Consumer, Predicate) do not allow checked exceptions. To wrap an I/O throwing method as a lambda, you can:
1. Define your own functional interface with throws Exception.
2. Catch and rethrow as RuntimeException inside the lambda.
3. Use @FunctionalInterface with E extends Throwable generics on a custom interface.
4. Use Lombok's @SneakyThrows (controversial, but concise). Externalizable extends Serializable and gives the class full control over its serialization by implementing writeExternal(ObjectOutput) and readExternal(ObjectInput).
Differences from Serializable:
• A public no-arg constructor is required (used during deserialization).
• You decide exactly which fields to write and how to encode them — can be more efficient and version-tolerant.
• Default constructor can run custom initialization before fields are restored.

Question 25 Java Programming

What is the difference between wait() / notify() and the higher-level concurrency utilities?

SOLID = five design principles:
• Single Responsibility: a class has one reason to change.
• Open/Closed: open for extension, closed for modification.
• Liskov Substitution: subtypes must be substitutable for their base types.
• Interface Segregation: prefer many small interfaces over one fat interface.
• Dependency Inversion: depend on abstractions, not concretions.
They guide maintainable, testable object-oriented design. wait()/notify() are low-level primitives on every object's monitor — they require the calling thread to own the object's monitor, are easy to misuse (lost wakeups, illegal monitor state), and offer no fairness.
Higher-level utilities in java.util.concurrent — BlockingQueue, CountDownLatch, CyclicBarrier, Semaphore, Phaser, ConcurrentMap, CompletableFuture — are safer, clearer, and more performant.
Rule of thumb: avoid wait()/notify() in new code; use the higher-level utilities instead. Externalizable extends Serializable and gives the class full control over its serialization by implementing writeExternal(ObjectOutput) and readExternal(ObjectInput).
Differences from Serializable:
• A public no-arg constructor is required (used during deserialization).
• You decide exactly which fields to write and how to encode them — can be more efficient and version-tolerant.
• Default constructor can run custom initialization before fields are restored. Builder separates the construction of a complex object from its representation, allowing step-by-step configuration. Useful when an object has many optional parameters or telescoping constructors become unreadable.
Example: new User.Builder("Alice").age(30).email("a@b.com").admin(true).build();
Lombok's @Builder and Java 16+ records reduce boilerplate. Effective Java Item 2 strongly recommends builders over constructors for many-parameter classes.

Question 26 Java Programming

What is polymorphism in Java?

Polymorphism lets objects take many forms.
Compile-time (method overloading): same method name, different parameters.
Runtime (method overriding): subclass provides its own implementation of a parent method. Resolved via dynamic method dispatch. You can bind the matched object to a variable directly:

if (obj instanceof String s) {
  System.out.println(s.length());
}

The variable s is in scope only where the type is known to be String. Eliminates the traditional cast + temporary variable pattern. Combined with switch patterns (Java 21+), it enables exhaustive type-based dispatch on sealed hierarchies. synchronized ensures that only one thread can access a block of code or method at a time, preventing race conditions.
Usage:
synchronized void increment() { count++; }
Or as a block: synchronized(lockObject) { // critical section }
It acquires an intrinsic lock (monitor) on the object. The diamond problem arises in multiple inheritance: two super-interfaces declare default methods with the same signature, and a class implementing both does not know which to inherit.
Java's rule: the implementing class must override the conflicting method (the compiler refuses to pick one). Inside the override, you can call a specific super's version with InterfaceA.super.method();.
This is different from C++ where the same class can suffer data-member ambiguities.

Question 27 Java Programming

What is serialization in Java and what is its main pitfall?

Selector allows a single thread to multiplex many non-blocking SelectableChannel instances (sockets, pipes). Steps:
1. Open selector: Selector.open().
2. Register channels: channel.register(selector, SelectionKey.OP_READ).
3. Loop: selector.select() returns the count of channels with events.
4. Iterate selectedKeys(), handle READ/WRITE/ACCEPT/CONNECT.
It is the foundation of high-performance servers (Netty, Jetty, gRPC Java). Strong — normal Object o = new Object(); prevents GC as long as reachable.
Soft — SoftReference; cleared by GC only when memory is needed (heap-pressure sensitive). Used for memory-sensitive caches.
Weak — WeakReference; cleared at the next GC cycle. Used by WeakHashMap to auto-evict entries when keys are no longer strongly reachable.
Phantom — PhantomReference; enqueued after the object is finalized, before its memory is reclaimed. Used to schedule post-mortem cleanup actions.
Only soft and weak are typically used directly; phantoms are advanced. Serialization converts an object to a byte stream via ObjectOutputStream / ObjectInputStream. A class opts in by implementing Serializable (a marker). On deserialization the JVM bypasses constructors — fields are populated reflectively. serialVersionUID controls version compatibility.
Pitfalls:
• Constructor bypass breaks invariants.
• Hidden security risks: deserialization gadget chains can execute attacker code (Java 8+ validates ObjectInputFilter to mitigate).
• Brittle to refactoring.
Prefer JSON/Protobuf for cross-system exchange; reserve Serializable for short-lived caches. ConcurrentHashMap is a thread-safe map with fine-grained locking / lock-free reads (Java 8+ uses CAS + synchronized per bucket, no global lock). It allows concurrent reads and a high degree of concurrent writes, and weakly consistent iterators that do not throw ConcurrentModificationException.
Hashtable locks the entire map on every operation → poor scalability under contention. ConcurrentHashMap forbids null keys and values; Hashtable also forbids nulls. Prefer ConcurrentHashMap for concurrent maps.

Question 28 Java Programming

What is a StringJoiner / String.join()?

ThreadPoolExecutor is configured with 7 core parameters:
• corePoolSize — minimum threads kept alive.
• maximumPoolSize — upper limit.
• keepAliveTime / unit — idle time before surplus threads die.
• workQueue — holds tasks waiting for a thread.
• threadFactory — creates threads (set names!).
• handler — RejectedExecutionHandler for when the pool and queue are full (e.g. AbortPolicy, CallerRunsPolicy).
Prefer ThreadPoolExecutor over the Executors shortcuts so you can name threads and choose the queue safely. volatile ensures that a variable's value is always read from and written to main memory, not a thread's local cache. It guarantees visibility across threads but does not guarantee atomicity.
Example: private volatile boolean running = true;
Use for simple flags shared between threads. String.join(delim, elements) concatenates an iterable/array of strings with the given delimiter: String.join(", ", "a", "b", "c"); → "a, b, c".
StringJoiner is a mutable builder for the same idea with prefix/suffix: new StringJoiner(", ", "[", "]").
Both are convenient for one-shot joins. For repeated building use StringBuilder or Collectors.joining(...) in Streams. map(Function) — returns Stream<R> for any R; no special numeric operations.
mapToInt(ToIntFunction) — returns IntStream, an autoboxing-free primitive stream. Provides sum(), average(), summaryStatistics(), range() factories, and is generally faster for numeric pipelines.
Similar mapToLong / mapToDouble variants exist. Convert back to object stream with boxed().

Question 29 Java Programming

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

HashSet: uses a hash table internally. O(1) add/remove/contains. No ordering guarantee. Allows one null.
TreeSet: uses a red-black tree. O(log n) operations. Elements are stored in sorted order. Does not allow null. Implements NavigableSet. Fail-fast iterators (default for most java.util collections like ArrayList, HashMap) detect concurrent modification via a modCount check and throw ConcurrentModificationException on next iteration after structural change. They are weakly consistent only on the surface — strictly not safe for concurrent mutation.
Fail-safe / weakly consistent iterators (concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList) operate on a snapshot or with weak ordering; they do not throw on concurrent modification and never see modified elements retroactively. int[] — a primitive array; stores raw 32-bit ints contiguously; no autoboxing overhead; cannot be used where Object[] is required.
Integer[] — an array of object references to boxed Integers; each element is a heap-allocated object; works with generics (List<Integer>) and reflection.
For numeric processing, primitive arrays (or libraries like Trove, Eclipse Collections, IntStream) avoid boxing. For collections of arbitrary size in generic code, use wrappers. ThreadPoolExecutor is configured with 7 core parameters:
• corePoolSize — minimum threads kept alive.
• maximumPoolSize — upper limit.
• keepAliveTime / unit — idle time before surplus threads die.
• workQueue — holds tasks waiting for a thread.
• threadFactory — creates threads (set names!).
• handler — RejectedExecutionHandler for when the pool and queue are full (e.g. AbortPolicy, CallerRunsPolicy).
Prefer ThreadPoolExecutor over the Executors shortcuts so you can name threads and choose the queue safely.

Question 30 Java Programming

What is the var keyword (local variable type inference) in Java 10+?

ThreadPoolExecutor is configured with 7 core parameters:
• corePoolSize — minimum threads kept alive.
• maximumPoolSize — upper limit.
• keepAliveTime / unit — idle time before surplus threads die.
• workQueue — holds tasks waiting for a thread.
• threadFactory — creates threads (set names!).
• handler — RejectedExecutionHandler for when the pool and queue are full (e.g. AbortPolicy, CallerRunsPolicy).
Prefer ThreadPoolExecutor over the Executors shortcuts so you can name threads and choose the queue safely. The Java Platform Module System (Project Jigsaw) groups packages into modules declared in module-info.java:

module com.example.app {
  requires java.sql;
  exports com.example.api;
  opens com.example.model to com.fasterxml.jackson;
}

requires = dependency; exports = public API; opens = reflective access for libraries like Spring/JPA. requires transitive re-exports a dependency. Modules enable reliable configuration, strong encapsulation, and a smaller custom runtime image via jlink. CountDownLatch lets one or more threads wait until a set of operations performed in other threads completes. It is initialized with a count; each countDown() decrements it; await() blocks until the count reaches zero (or times out).
Use it to wait for N services to initialize, or for N tasks to finish before aggregating. The latch is single-use; once the count hits zero it cannot be reset — for cyclic reuse use CyclicBarrier or Phaser. var lets the compiler infer the type of a local variable from its initializer: var list = new ArrayList<String>();
Restrictions:
• Only for local variables (with initializer), for loop indices, and lambda parameters (Java 11+).
• Not allowed for fields, method parameters, or return types.
• Type is fixed at compile time; reassignment must be to compatible types.
• Avoid var when the right-hand side is non-obvious (e.g. var x = method();) — readability suffers.

Question 31 Java Programming

What is the Map.compute() / computeIfAbsent() / computeIfPresent() family?

PECS — when writing a method that consumes or produces generic values:
• If you only read from a collection (it's a producer), use ? extends T.
• If you only write into a collection (it's a consumer), use ? super T.
Example: void copy(List<? extends T> src, List<? super T> dest) — read from src, write to dest.
Mnemonic: "Get and Put" = extends in the "get" (producer) position, super in the "put" (consumer) position. Observer defines a one-to-many dependency so that when one object (the subject) changes state, all its dependents (observers) are notified.
Pre-9: java.util.Observer / Observable — deprecated.
Modern Java: implement your own interface (addListener, removeListener, fireEvent), or use PropertyChangeListener / PropertyChangeSupport (in java.beans), or use Flow API (Reactive Streams) for backpressure-aware streams.
Libraries: RxJava, Reactor, Guava EventBus. Modern Map defaults for atomic, conditional updates:
• map.compute(key, (k,v) -> newValue) — always set (or remove) based on key+old value.
• map.computeIfAbsent(key, k -> newValue) — only set if absent; atomic on ConcurrentHashMap; common for memoization and Map<String, List<X>> caches.
• map.computeIfPresent(key, (k,v) -> transformed) — only update if key present.
• map.merge(key, value, remappingFunction) — combine old + new (e.g. add counts).
Prefer these over get-then-put to avoid race conditions and null-handling bugs. Java 11 added Predicate.not(p) as a static factory equivalent to p.negate() but more useful with method references:
list.removeIf(Predicate.not(String::isBlank)); is clearer than list.removeIf(s -> !s.isBlank());.
It is also a workaround for overload resolution ambiguity: passing a method reference to an IntPredicate/Predicate overload that is otherwise ambiguous.

Question 32 Java Programming

What is EnumSet and EnumMap and why are they efficient?

• Collections.synchronizedList — wraps any List with coarse-grained locking; simple, slow under contention.
• CopyOnWriteArrayList — wait-free reads, expensive copies on writes; great for listener registries.
• ConcurrentLinkedQueue — non-blocking MPMC queue; best for producer/consumer throughput.
• ArrayDeque + BlockingQueue variants when bounded capacity is needed.
Pick based on read/write ratio and access pattern, not a single rule. EnumSet is a Set optimized for enum keys, backed by a single long bitmask (or multiple for large enums) — O(1) add/remove/contains with tiny memory footprint.
EnumMap is a Map optimized for enum keys, backed by an array indexed by ordinal.
Both are far faster than HashSet/HashMap for enum keys. They are not thread-safe; wrap with Collections.synchronizedSet or Set.of(...) for immutability. Use them whenever keys are enums. A method reference is a shorthand for a lambda that calls an existing method. Four kinds:
1. Static: Math::sqrt → x -> Math.sqrt(x).
2. Instance on a particular object: System.out::println → x -> System.out.println(x).
3. Instance on an arbitrary object of a given type: String::length → s -> s.length().
4. Constructor: ArrayList::new → () -> new ArrayList(). Switch expressions use arrow syntax and return a value:

String label = switch (day) {
  case MONDAY, FRIDAY, SUNDAY -> "fun";
  case TUESDAY -> "meh";
  default -> "other";
};

Exhaustiveness is checked for enum switches — if all cases are covered, no default is required. Combined with sealed types, the compiler can prove all cases handled. Replaces verbose break;-laden switch statements.

Question 33 Java Programming

What is the Producer-Consumer pattern in Java and how is it typically implemented?

Producer-consumer decouples threads that produce items from threads that consume them via a shared bounded queue. The producer blocks when the queue is full; the consumer blocks when empty.
Canonical Java implementation:

BlockingQueue<Task> q = new ArrayBlockingQueue<>(100);
// producer: q.put(task);
// consumer: Task t = q.take();

This pattern naturally provides backpressure and is the basis for Executor work queues. CountDownLatch lets one or more threads wait until a set of operations performed in other threads completes. It is initialized with a count; each countDown() decrements it; await() blocks until the count reaches zero (or times out).
Use it to wait for N services to initialize, or for N tasks to finish before aggregating. The latch is single-use; once the count hits zero it cannot be reset — for cyclic reuse use CyclicBarrier or Phaser. A stack trace is a snapshot of the call stack at the moment an exception is thrown, listing class, method, file, and line. "Caused by" chains show the underlying root cause of a wrapped exception. The last "Caused by" is the original root cause; the first exception is the one the application actually saw.
Use Throwable.getCause(), getSuppressed(), and initCause() programmatically. Tools: Arrays.asList(e.getStackTrace()) or libraries like grep over logs. • Parallel GC — throughput-oriented, stop-the-world, full GC pauses; good for batch workloads.
• G1 GC (default since Java 9) — regional, mostly-concurrent, balances throughput and latency; target -XX:MaxGCPauseMillis.
• ZGC (Java 11+) — sub-millisecond pauses regardless of heap size, concurrent; great for very large heaps (multi-GB to TB) and latency-sensitive services.
• Shenandoah — similar to ZGC, low-pause concurrent collector.
Pick by SLA: ZGC/Shenandoah for <10 ms pauses, G1 for balanced, Parallel for batch.

Question 34 Java Programming

What is the difference between == and equals() in Java?

volatile ensures that a variable's value is always read from and written to main memory, not a thread's local cache. It guarantees visibility across threads but does not guarantee atomicity.
Example: private volatile boolean running = true;
Use for simple flags shared between threads. JDK (Java Development Kit) includes tools for developing Java programs.
JRE (Java Runtime Environment) provides libraries and JVM to run Java applications.
JVM (Java Virtual Machine) executes the bytecode. Relationship: JDK ⊃ JRE ⊃ JVM. map() applies a Function<T,R> to each element and returns a stream of R — one-to-one transformation.
flatMap() applies a Function<T, Stream<R>> and flattens the resulting streams into one — useful for one-to-many (e.g. splitting strings into words, optional unwrapping, nested collections).
Example: words.stream().flatMap(line -> Arrays.stream(line.split(" "))). == compares reference equality (whether two variables point to the same object in memory).
.equals() compares value equality (logical content).
Example: new String("hi") == new String("hi") is false, but new String("hi").equals(new String("hi")) is true.

Question 35 Java Programming

What is the Factory Method design pattern in Java?

transient (storage modifier): a field marked transient is excluded from default Serializable serialization. Useful for non-serializable state, derived values, or sensitive data.
volatile (visibility modifier): a field marked volatile is read/written directly to main memory, providing cross-thread visibility.
They are unrelated — transient concerns persistence; volatile concerns concurrency. Both are applied to fields, not methods. Factory Method defines an interface for creating objects but lets subclasses decide which class to instantiate.
Example shape:

interface AnimalFactory { Animal create(); }
class DogFactory implements AnimalFactory { public Animal create() { return new Dog(); } }

Benefits: decouples client code from concrete classes, centralizes construction logic, easier to extend with new product types without modifying existing code. A text block is a multi-line string literal delimited by """:

String json = """
  {
    "name": "Alice",
    "age": 30
  }
  """;

Indentation and incidental whitespace are normalized. String.stripIndent() / translateEscapes() are also available on the literal. Text blocks don't contain \r; embedded \ at line end joins lines. Java 11 added Predicate.not(p) as a static factory equivalent to p.negate() but more useful with method references:
list.removeIf(Predicate.not(String::isBlank)); is clearer than list.removeIf(s -> !s.isBlank());.
It is also a workaround for overload resolution ambiguity: passing a method reference to an IntPredicate/Predicate overload that is otherwise ambiguous.

Question 36 Java Programming

What is the difference between BIO, NIO, and NIO.2 in Java?

Modern Map defaults for atomic, conditional updates:
• map.compute(key, (k,v) -> newValue) — always set (or remove) based on key+old value.
• map.computeIfAbsent(key, k -> newValue) — only set if absent; atomic on ConcurrentHashMap; common for memoization and Map<String, List<X>> caches.
• map.computeIfPresent(key, (k,v) -> transformed) — only update if key present.
• map.merge(key, value, remappingFunction) — combine old + new (e.g. add counts).
Prefer these over get-then-put to avoid race conditions and null-handling bugs. Resources are closed in the reverse order of their declaration, in a finally-equivalent block. Each resource is closed even if an exception occurs while opening or closing another.
Suppressed exceptions from earlier failures are attached to the primary exception via Throwable.addSuppressed(); retrieve them with e.getSuppressed().
Resources must implement AutoCloseable (most I/O classes do). BIO (blocking I/O) — classic java.io; one thread per socket; simple but scales poorly beyond a few hundred connections.
NIO (java.nio, Java 1.4+) — non-blocking channels, buffers, selectors; one thread can handle many connections; the basis of high-performance servers.
NIO.2 (Java 7+) — asynchronous I/O with AsynchronousChannel, AsynchronousFileChannel, callback-based or Future-based completion; plus the modern Path/Files API. NIO.2 is for true async, distinct from NIO's non-blocking polling. Factory Method defines an interface for creating objects but lets subclasses decide which class to instantiate.
Example shape:

interface AnimalFactory { Animal create(); }
class DogFactory implements AnimalFactory { public Animal create() { return new Dog(); } }

Benefits: decouples client code from concrete classes, centralizes construction logic, easier to extend with new product types without modifying existing code.

Question 37 Java Programming

What is the PECS rule (Producer Extends Consumer Super) in Java generics?

reduce(identity, accumulator) — folds the stream into a single value using an associative, ideally stateless binary operator. Example: sum = list.stream().reduce(0, Integer::sum);.
collect(supplier, accumulator, combiner) — accumulates into a mutable container (e.g. StringBuilder, List). The combiner merges partial results, enabling efficient parallel collection.
Use collect when you build a collection; reduce for scalar folds. The 1-arg reduce returning Optional has weaker guarantees in parallel. Annotations provide metadata about the code. They do not directly affect execution but can be processed at compile time or runtime.
Common annotations:

@Override – method overrides a superclass method
@Deprecated – marks code as obsolete
@SuppressWarnings – suppresses compiler warnings
@FunctionalInterface – validates single abstract method

Abstraction hides implementation details and shows only functionality. Achieved through:

Abstract classes – declared with abstract keyword, can have both abstract and concrete methods
Interfaces – define a contract of methods a class must implement

PECS — when writing a method that consumes or produces generic values:
• If you only read from a collection (it's a producer), use ? extends T.
• If you only write into a collection (it's a consumer), use ? super T.
Example: void copy(List<? extends T> src, List<? super T> dest) — read from src, write to dest.
Mnemonic: "Get and Put" = extends in the "get" (producer) position, super in the "put" (consumer) position.

Question 38 Java Programming

What is inheritance in Java?

ConcurrentHashMap is a thread-safe map with fine-grained locking / lock-free reads (Java 8+ uses CAS + synchronized per bucket, no global lock). It allows concurrent reads and a high degree of concurrent writes, and weakly consistent iterators that do not throw ConcurrentModificationException.
Hashtable locks the entire map on every operation → poor scalability under contention. ConcurrentHashMap forbids null keys and values; Hashtable also forbids nulls. Prefer ConcurrentHashMap for concurrent maps. Every loaded class has a Class<?> object. Obtained via:
• String.class — compile-time literal.
• obj.getClass() — runtime instance.
• Class.forName("com.x.Y") — fully qualified name (throws ClassNotFoundException).
• ClassLoader.loadClass("...").
The Class object exposes metadata: name, modifiers, fields, constructors, methods, annotations, generic supertype, and the classloader. It's the entry point for reflection and dynamic proxy creation. Inheritance allows a class to acquire properties and methods of another class using the extends keyword. Java supports single inheritance for classes.
Example: class Dog extends Animal { } Switch expressions use arrow syntax and return a value:

String label = switch (day) {
  case MONDAY, FRIDAY, SUNDAY -> "fun";
  case TUESDAY -> "meh";
  default -> "other";
};

Exhaustiveness is checked for enum switches — if all cases are covered, no default is required. Combined with sealed types, the compiler can prove all cases handled. Replaces verbose break;-laden switch statements.

Question 39 Java Programming

What is CompletableFuture in Java 8?

Composition over inheritance favors "has-a" relationships over "is-a" by embedding an instance of another class and delegating to it.
Benefits: avoids tight coupling to a parent's fragile public API, prevents the fragile base class problem, and lets you swap implementations at runtime via interfaces.
Rule of thumb: extend only when the subclass truly is a specialization and you control both classes. stream() processes elements sequentially on the calling thread; results stay in encounter order and behavior is deterministic.
parallelStream() splits the work across multiple threads using the common ForkJoinPool; performance gains depend on data size, CPU cores, and the cost per element. Side effects in operations become unsafe, and ordering is not guaranteed for unordered sources. Use parallel only for CPU-bound work on large datasets with stateless operations. CompletableFuture<T> implements Future<T> and CompletionStage<T>, supporting composable, asynchronous pipelines.
Key methods:
• supplyAsync(() -> value) / runAsync(runnable).
• thenApply(), thenAccept(), thenRun() — chain transformations.
• thenCompose() — flatten a nested future (like flatMap).
• thenCombine() — combine two independent futures.
• exceptionally() / handle() — recover from errors.
• allOf() / anyOf() — aggregate multiple futures.
By default uses the common ForkJoinPool; pass a custom Executor for control. this refers to the current object instance. Common uses:

Distinguish instance variables from parameters: this.name = name;
Call another constructor: this(args);
Pass the current object as an argument

Question 40 Java Programming

What is the difference between peek() and forEach() in Streams?

peek(Consumer) is an intermediate operation intended for debugging; it executes only when a downstream terminal operation runs, and its behavior is undefined in parallel streams if the action mutates shared state.
forEach(Consumer) is a terminal operation that processes every element and is guaranteed to run.
Rule: do not use peek() for side effects in production code; use it only in debug logs. Use forEach() for side effects. thenApply() takes a Function<T, U> and returns CompletableFuture — transforms a value when the future completes (analogous to map()).
thenCompose() takes a Function<T, CompletionStage> and flattens the result, avoiding CompletableFuture<CompletableFuture> (analogous to flatMap()).
Use thenCompose() whenever the next step itself returns a future (chaining async calls). Use thenApply() for synchronous value transformations. • Runnable — no args, no return, can throw any Exception. void run().
• Supplier<T> — no args, returns T, no checked exceptions. T get().
• Callable<V> — no args, returns V, can throw checked Exception. V call().
Use Runnable for fire-and-forget tasks; Supplier for lazy value generation; Callable for asynchronous tasks that return a result or throw checked exceptions. Generics enable types (classes, interfaces, methods) to operate on parameterized types, providing compile-time type safety.
Example: List<String> names = new ArrayList<>();
Benefits: eliminates casting, catches type errors at compile time, and enables reusable code.

Question 41 Java Programming

What is the atomicity gap on long and double in Java?

transient (storage modifier): a field marked transient is excluded from default Serializable serialization. Useful for non-serializable state, derived values, or sensitive data.
volatile (visibility modifier): a field marked volatile is read/written directly to main memory, providing cross-thread visibility.
They are unrelated — transient concerns persistence; volatile concerns concurrency. Both are applied to fields, not methods. Writes and reads of long and double (64-bit) are not guaranteed atomic by the JMM without a modifier — they can be split into two 32-bit operations, allowing a thread to read a torn value.
To guarantee atomicity, declare them volatile or access them under a synchronized block. int, short, byte, float, and references are always atomic.
For compound operations (e.g. counter++) even volatile is insufficient — use AtomicInteger / AtomicLong or proper locking. Strong — normal Object o = new Object(); prevents GC as long as reachable.
Soft — SoftReference; cleared by GC only when memory is needed (heap-pressure sensitive). Used for memory-sensitive caches.
Weak — WeakReference; cleared at the next GC cycle. Used by WeakHashMap to auto-evict entries when keys are no longer strongly reachable.
Phantom — PhantomReference; enqueued after the object is finalized, before its memory is reclaimed. Used to schedule post-mortem cleanup actions.
Only soft and weak are typically used directly; phantoms are advanced. Method overriding occurs when a subclass provides a specific implementation of a method already defined in its superclass. The method signature must be identical. Annotate with @Override. It is a form of runtime polymorphism.

Question 42 Java Programming

What is the DAO pattern in Java?

Data Access Object (DAO) abstracts persistence by providing an interface of domain operations (findById, save, delete) and one or more implementations (JDBC, JPA, in-memory for tests).
Benefits: business logic is independent of storage technology, easier to unit test (inject a mock DAO), and the same business code can switch between SQL, NoSQL, or a cache by swapping the DAO.
DAOs typically map 1:1 to a domain entity and return plain domain objects, not DTOs or rows. Annotations provide metadata about the code. They do not directly affect execution but can be processed at compile time or runtime.
Common annotations:

@Override – method overrides a superclass method
@Deprecated – marks code as obsolete
@SuppressWarnings – suppresses compiler warnings
@FunctionalInterface – validates single abstract method

reduce(identity, accumulator) — folds the stream into a single value using an associative, ideally stateless binary operator. Example: sum = list.stream().reduce(0, Integer::sum);.
collect(supplier, accumulator, combiner) — accumulates into a mutable container (e.g. StringBuilder, List). The combiner merges partial results, enabling efficient parallel collection.
Use collect when you build a collection; reduce for scalar folds. The 1-arg reduce returning Optional has weaker guarantees in parallel. The JVM uses a parent-delegation hierarchy:
1. Bootstrap class loader — loads core JDK classes (rt.jar / jrt-fs); implemented in native code; returns null as parent.
2. Platform (extension) class loader — loads Java SE platform extensions.
3. Application (system) class loader — loads classes from the classpath.
Each loader first delegates to its parent before trying to load itself, preventing custom classes from spoofing core types. Custom classloaders are common in app servers, OSGi, and plugin systems.

Question 43 Java Programming

What is the difference between throw and throws in Java?

A record is a compact, immutable data class. The compiler generates the constructor, accessors (name(), not getName()), equals(), hashCode(), and toString() from its components.
Example: public record Point(int x, int y) {}
Records cannot extend other classes (implicitly extend Record), but can implement interfaces. They are ideal for DTOs, value objects, and tuples. Use compact constructors for validation and additional explicit methods/components as needed. Spliterator ("split iterator") is the internal traversal mechanism behind Streams. It can partition a source into sub-sources, supports parallel processing, and reports characteristics via characteristics() (e.g. ORDERED, DISTINCT, SORTED, SIZED, IMMUTABLE).
Most developers never implement one directly, but understanding it explains why some streams parallelize well and others do not. throw is a statement used to actually raise an exception: throw new IllegalArgumentException("bad");.
throws is a method-signature clause declaring that the method may propagate one or more exception types: void read() throws IOException { ... }.
You can throw any Throwable; throws is required only for checked exceptions (and Error subclasses are allowed but unnecessary). Fork/Join (Java 7+) is a framework for parallelizing divide-and-conquer tasks. It uses a work-stealing ForkJoinPool: idle threads steal tasks from busy threads' deques, balancing load.
Tasks extend RecursiveTask<V> (returns a result) or RecursiveAction (no result) and implement compute(), calling fork() on subtasks and join() to collect results. parallelStream() uses the common pool by default; configure parallelism with System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "N").

Question 44 Java Programming

What is StampedLock in Java 8?

Multithreading allows concurrent execution of two or more threads. Create threads by:

Extending Thread class and overriding run()
Implementing Runnable interface
Using ExecutorService (preferred)

Start a thread with thread.start(), not thread.run(). StampedLock (in java.util.concurrent.locks) supports three modes:
• Write lock — exclusive.
• Read lock — shared.
• Optimistic read — a non-blocking stamp; later validate the stamp with validate(stamp) and re-read if invalid.
Optimistic reads are extremely fast for read-mostly data because they avoid CAS. StampedLock is not reentrant and has no notion of ownership; the same thread reentering a write lock it already holds can deadlock. Both produce elements in natural order, but:
• List.sort(Comparator) modifies the list in place (throws UnsupportedOperationException on unmodifiable lists); supports a custom comparator and is generally faster (no stream pipeline overhead).
• stream.sorted() returns a new stream; the original collection is unchanged; lazier and works inside larger pipelines. Requires the stream to be consumed by a terminal op before order is realized. @FunctionalInterface is an informative annotation that tells the compiler to verify the interface has exactly one abstract method. It is not required for an interface to be usable as a lambda target — the compiler treats any SAM type as a functional interface regardless of the annotation.
Always add it to your functional interfaces: it documents intent and prevents future maintainers from accidentally breaking the contract by adding a second abstract method.

Question 45 Java Programming

What is the difference between deep copy and shallow copy?

Intrinsic lock (every Java object has one) is acquired/released with the synchronized keyword — basic, reentrant, automatically released on exception.
Explicit lock (java.util.concurrent.locks.Lock via ReentrantLock) offers: tryLock(), timed lock acquisition, multiple Condition variables, and fair-vs-unfair policies. ReentrantLock must be released in a finally block.
Prefer synchronized unless you need its advanced features. A shallow copy duplicates the top-level object but shares references to nested mutable objects: modifying the inner list of the copy also affects the original.
A deep copy recursively duplicates all referenced objects, so the copy and the original share nothing.
Java's Object.clone() is shallow by default; deep copy usually requires a copy constructor, serialization round-trip, or manual recursion. A Java enum is a special class representing a fixed set of constants. It can have:
• Fields and a constructor (always private).
• Methods (including abstract ones — each constant can override).
• Implement interfaces.
• Per-constant behavior via abstract methods.
Example:

enum Operation { ADD { int apply(int a,int b){return a+b;} }, SUB { int apply(int a,int b){return a-b;} }; abstract int apply(int,int); }

Enums are implicitly final, extend java.lang.Enum, and are safely usable in switch statements and EnumSet/EnumMap. reduce(identity, accumulator) — folds the stream into a single value using an associative, ideally stateless binary operator. Example: sum = list.stream().reduce(0, Integer::sum);.
collect(supplier, accumulator, combiner) — accumulates into a mutable container (e.g. StringBuilder, List). The combiner merges partial results, enabling efficient parallel collection.
Use collect when you build a collection; reduce for scalar folds. The 1-arg reduce returning Optional has weaker guarantees in parallel.

Question 46 Java Programming

What is the String Pool in Java?

The Stream API (Java 8+) processes collections of objects in a functional style.
Key characteristics: lazy evaluation, supports parallel processing, does not modify the source.
Example:

list.stream()
  .filter(s -> s.length() > 3)
  .map(String::toUpperCase)
  .collect(Collectors.toList());

IntStream.range(start, end) — exclusive end: produces start, start+1, ..., end-1.
IntStream.rangeClosed(start, end) — inclusive end: produces start, start+1, ..., end.
For large known sequences prefer iterate(seed, hasNext, next) or generate(supplier) for arbitrary streams; use range* for integer ranges, e.g. IntStream.rangeClosed(1, 10).sum() → 55. Producer-consumer decouples threads that produce items from threads that consume them via a shared bounded queue. The producer blocks when the queue is full; the consumer blocks when empty.
Canonical Java implementation:

BlockingQueue<Task> q = new ArrayBlockingQueue<>(100);
// producer: q.put(task);
// consumer: Task t = q.take();

This pattern naturally provides backpressure and is the basis for Executor work queues. The String Pool (or intern pool) is a special memory area in the heap where the JVM stores string literals. When you write String s = "hello";, the JVM checks the pool first and reuses existing objects, saving memory. Use intern() to add a string to the pool explicitly.

Question 47 Java Programming

What is the Builder pattern and when is it useful in Java?

Builder separates the construction of a complex object from its representation, allowing step-by-step configuration. Useful when an object has many optional parameters or telescoping constructors become unreadable.
Example: new User.Builder("Alice").age(30).email("a@b.com").admin(true).build();
Lombok's @Builder and Java 16+ records reduce boilerplate. Effective Java Item 2 strongly recommends builders over constructors for many-parameter classes. this refers to the current object instance. Common uses:

Distinguish instance variables from parameters: this.name = name;
Call another constructor: this(args);
Pass the current object as an argument

Java I/O is organized into:
Byte streams: InputStream / OutputStream – for binary data.
Character streams: Reader / Writer – for text data.
Common classes:

FileInputStream / FileOutputStream
BufferedReader / BufferedWriter
PrintWriter

Always close streams or use try-with-resources. Classes in java.util.concurrent.atomic providing lock-free, thread-safe operations on single variables using low-level CAS (compare-and-swap) CPU instructions.
Key methods: incrementAndGet(), getAndIncrement(), compareAndSet(expected, new), updateAndGet(), and Java 8+ accumulateAndGet() / getAndAccumulate().
Use them for counters and flags; they outperform synchronized for low-to-moderate contention. Combine with AtomicReference for non-blocking stacks and queues.

Question 48 Java Programming

What is composition over inheritance in Java?

stream() processes elements sequentially on the calling thread; results stay in encounter order and behavior is deterministic.
parallelStream() splits the work across multiple threads using the common ForkJoinPool; performance gains depend on data size, CPU cores, and the cost per element. Side effects in operations become unsafe, and ordering is not guaranteed for unordered sources. Use parallel only for CPU-bound work on large datasets with stateless operations. Composition over inheritance favors "has-a" relationships over "is-a" by embedding an instance of another class and delegating to it.
Benefits: avoids tight coupling to a parent's fragile public API, prevents the fragile base class problem, and lets you swap implementations at runtime via interfaces.
Rule of thumb: extend only when the subclass truly is a specialization and you control both classes. You can bind the matched object to a variable directly:

if (obj instanceof String s) {
  System.out.println(s.length());
}

The variable s is in scope only where the type is known to be String. Eliminates the traditional cast + temporary variable pattern. Combined with switch patterns (Java 21+), it enables exhaustive type-based dispatch on sealed hierarchies. HashMap: stores key-value pairs in a hash table. O(1) average lookup. No ordering of keys. Allows one null key.
TreeMap: stores entries in a red-black tree. O(log n) lookup. Keys are sorted in natural order or by a custom Comparator. Does not allow null keys.

Question 49 Java Programming

What is reflection in Java?

HashSet: uses a hash table internally. O(1) add/remove/contains. No ordering guarantee. Allows one null.
TreeSet: uses a red-black tree. O(log n) operations. Elements are stored in sorted order. Does not allow null. Implements NavigableSet. Annotations provide metadata about the code. They do not directly affect execution but can be processed at compile time or runtime.
Common annotations:

@Override – method overrides a superclass method
@Deprecated – marks code as obsolete
@SuppressWarnings – suppresses compiler warnings
@FunctionalInterface – validates single abstract method

Reflection lets a program inspect and manipulate classes, fields, methods, and constructors at run time via java.lang.reflect.
Capabilities:
• Load classes by name: Class.forName("com.x.Y").
• Instantiate: ctor.newInstance().
• Read/write fields (including private): field.set(obj, value).
• Invoke methods: method.invoke(target, args).
Drawbacks: slower, breaks encapsulation, fragile across refactors, security restrictions under module system. Use frameworks like Spring/Hibernate, but prefer compile-time solutions (generics, sealed types) when possible. Bounded types restrict the types that can be used as generic arguments.
Upper bound: <T extends Number> – T must be Number or a subclass.
Lower bound (wildcards): <? super Integer> – accepts Integer or any superclass.
Unbounded wildcard: <?> – accepts any type.

Question 50 Java Programming

What is the difference between reduce() and collect() in Streams?

reduce(identity, accumulator) — folds the stream into a single value using an associative, ideally stateless binary operator. Example: sum = list.stream().reduce(0, Integer::sum);.
collect(supplier, accumulator, combiner) — accumulates into a mutable container (e.g. StringBuilder, List). The combiner merges partial results, enabling efficient parallel collection.
Use collect when you build a collection; reduce for scalar folds. The 1-arg reduce returning Optional has weaker guarantees in parallel. Java 11 added Predicate.not(p) as a static factory equivalent to p.negate() but more useful with method references:
list.removeIf(Predicate.not(String::isBlank)); is clearer than list.removeIf(s -> !s.isBlank());.
It is also a workaround for overload resolution ambiguity: passing a method reference to an IntPredicate/Predicate overload that is otherwise ambiguous. Autoboxing is the automatic conversion of a primitive to its wrapper object: Integer i = 42;
Unboxing is the reverse: int n = i;
The compiler inserts Integer.valueOf() and intValue() calls. Caveat: unboxing a null wrapper throws NullPointerException. For values in the IntegerCache range (-128..127) boxing returns the same cached instance. Encapsulation is the practice of keeping fields private and providing access through public getter and setter methods. This protects the internal state of an object and enforces data hiding.
Example: private int age; public int getAge() { return age; }