Ultimate Free Java Programming Course: Beginner to Advanced with Puzzles

Output: 3, 3.0, 3.5

Detailed Explanation: In Java, 7 / 2 performs integer division, truncating the quotient to 3. In double b = 7 / 2;, the division evaluates first to 3, which is widened to 3.0 on assignment. In double c = 7.0 / 2;, the literal 7.0 promotes 2 to 2.0, computing 3.5.

Output: -2147483648 (which is Integer.MIN_VALUE)

Detailed Explanation: Primitive integer operations silently wrap around on overflow according to 32-bit two's complement rules without throwing an exception. To catch arithmetic overflow, use Math.addExact(max, 1), which throws ArithmeticException.

Output: false

Detailed Explanation: Numbers like 0.1 and 0.2 cannot be represented with exact precision in IEEE 754 binary floating point. Their sum evaluates to 0.30000000000000004. In financial software, always use BigDecimal with String constructors: new BigDecimal("0.1").add(new BigDecimal("0.2")).

Output: Empty or null

Detailed Explanation: The logical OR operator (||) short-circuits: since the left expression str == null is true, the right expression str.isEmpty() is never executed. Using single-pipe | would evaluate both sides and crash with a NullPointerException.

Bug: Using single ampersand & causes both operands to evaluate unconditionally.

Fix: When user is null, evaluating user.isActive() throws a fatal NullPointerException. Replace with double ampersand user != null && user.isActive().

Output: true false true

Detailed Explanation: s1 and s2 reference the identical internalized object in the String Constant Pool, so s1 == s2 is true. The new operator forces allocation of a new instance on the general heap, so s1 == s3 is false. s1.equals(s3) is true because equals() compares character contents.

Issue: String immutability means every += creates a brand new String object and copies the preceding characters, resulting in quadratic $O(N^2)$ time and massive heap garbage collection pressure.

Solution: Use mutable StringBuilder: StringBuilder sb = new StringBuilder(); for (int i = 0; i < 10000; i++) sb.append(i); which executes in amortized linear $O(N)$ time.

Output: Double

Detailed Explanation: When ternary branches have different primitive wrapper types (e.g., Integer and Double), Java's type conversion rules unbox both to primitive int and double, promote the int to double (yielding 42.0), and then autobox the resulting value into a Double instance.

int level = switch (role) {
    case "ADMIN" -> 10;
    case "EDITOR" -> 5;
    default -> 1;
};

Explanation: Modern switch expressions eliminate error-prone break; statements, allow multiple labels per case, and return a value directly into variable assignments.

Output: int[]: [0, 0], boolean[]: [false, false], String[]: [null, null]

Detailed Explanation: In Java, all array elements allocated on the heap are automatically zero-initialized by the JVM before program access: numeric types get 0 (or 0.0), boolean gets false, char gets '\u0000', and reference types get null.

Output: 99 2

Detailed Explanation: In Java, object references are passed by value (a copy of the memory address pointer). Mutating arr[0] = 99 modifies the actual heap object shared by caller and callee. However, reassigning arr = new int[]... only updates the local parameter copy of the pointer, leaving nums pointing to the original array.

Output: 1

Detailed Explanation: The enhanced for-each loop variable val is a local copy of each array element. Mutating val = 0 changes only the local copy, not the underlying array slot. To modify elements, use a traditional indexed for-loop: values[i] = 0;.

Answer: A do-while loop is an exit-controlled loop that always executes its body at least once unconditionally, because the continuation condition check occurs at the very end of the loop body iteration.

outerLoop:
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 6) {
            break outerLoop; // Terminates the outer loop completely
        }
    }
}

Explanation: Prepending an identifier followed by a colon (e.g. outerLoop:) labels the loop. Calling break outerLoop; immediately exits the targeted outer iteration block.

Answer: test(int x) is invoked.

Detailed Explanation: Java compiler method resolution prioritizes exact type matches first. The literal 10 is of type int, matching test(int) exactly. Widening to long only occurs if no matching int overload exists.

Result: Throws java.lang.NullPointerException at runtime.

Detailed Explanation: The compiler automatically inserts a call to counter.intValue() to perform unboxing. Because counter is null, attempting to invoke an instance method on a null reference throws an immediate NullPointerException.

Detailed Explanation: The JVM maintains an internal IntegerCache for values between -128 and 127 (JLS 5.1.7). For values within this range, Integer.valueOf(100) returns identical cached object references, making a == b true. Beyond 127, new distinct heap instances are instantiated, making c == d false. Always use .equals() for wrapper object comparisons.

Output: 66 and B

Detailed Explanation: In Java arithmetic operations, char values are promoted to 32-bit integers. 'A' has ASCII code 65, so 'A' + 1 = 66. Casting back with (char)66 converts the integer into character 'B'.

Permitted: Local variable declarations inside methods, for-loop counters, and try-with-resources where an initializer is explicitly provided.

Prohibited: Class instance/static fields, method parameter types, method return types, and uninitialized variables (e.g. var x; is invalid).

Output: -1

Detailed Explanation: In Java (unlike Python which uses floor division), the remainder operator % adheres to truncated division: the sign of the result is determined strictly by the sign of the dividend (the left operand), so -7 % 3 = -1.

Output: -2147483648 (Negative!)

Detailed Explanation: Integer.MIN_VALUE is -2,147,483,648, but Integer.MAX_VALUE is only +2,147,483,647. Because the positive counterpart cannot be represented in a signed 32-bit integer, two's complement arithmetic overflows right back to Integer.MIN_VALUE. In Java 15+, use Math.absExact() to throw an ArithmeticException on this overflow.

Bug: This causes an infinite loop.

Explanation: A Java byte has a maximum value of 127. When b reaches 127 and increments by 1, it overflows to -128, which is still strictly less than 130. The loop condition b < 130 is perpetually true.

Output: Executes normally with NO exception.

Detailed Explanation: Static methods belong to the class, not instance objects. The compiler resolves static calls using the declared compile-time type of the reference variable (Printer.printLogo()), discarding the actual runtime instance reference completely. Thus, dereferencing null does not occur.

Answer: Evaluated at compile time.

Explanation: Because a and b are compile-time constants (final primitive variables with constant expressions), the Java compiler performs constant folding and directly generates bytecode loading the pre-calculated value 30 (bipush 30).

public static boolean isPalindrome(String s) {
    int left = 0, right = s.length() - 1;
    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

Complexity: Time $O(N)$, Space $O(1)$. It avoids allocating reversed strings in memory.

for (int i = 1; i <= 100; i++) {
    if (i % 15 == 0) System.out.println("FizzBuzz");
    else if (i % 3 == 0) System.out.println("Fizz");
    else if (i % 5 == 0) System.out.println("Buzz");
    else System.out.println(i);
}

x = x ^ y;
y = x ^ y; // y becomes original x
x = x ^ y; // x becomes original y

Caution: While an elegant interview puzzle, standard code should use a temporary variable for clarity and JIT compiler register optimization.

int count = Integer.bitCount(n);

Manual $O(k)$ Algorithm (Brian Kernighan's):

int count = 0;
while (n != 0) {
    n &= (n - 1); // Clears the lowest set bit
    count++;
}

Detailed Explanation: Scanner uses a small 1KB buffer and parses input against regular expression patterns, incurring high tokenization and boxing overhead. BufferedReader reads raw character data using a default 8KB buffer with simple, thread-safe line buffering, minimizing system call overhead.

Bug: If low + high exceeds $2^{31} - 1$, it overflows to a negative integer, causing an ArrayIndexOutOfBoundsException.

Overflow-Safe Formula:

int mid = low + (high - low) / 2; // Or unsigned bitshift: (low + high) >>> 1;

Cause: The compiler automatically inserts super(); (no-arg constructor) as the first statement in any constructor if not explicitly specified. Because Vehicle defines a parameterized constructor, the default no-arg constructor is not generated, resulting in a compilation error.

Fix: The subclass constructor must explicitly invoke super("VIN-001"); as its very first statement.

Output: 10 20

Detailed Explanation: In Java, fields are not polymorphic; they are resolved statically at compile time based on the declared reference type (Parent, where x = 10). In contrast, instance methods are overridden and dispatched dynamically at runtime via the virtual method table (vtable), invoking Child.getX() (returning 20).

class SuperFactory {
    public Number createNumber() { return 10; }
}
class SubFactory extends SuperFactory {
    @Override
    public Integer createNumber() { return 20; } // Covariant return type
}

Explanation: Yes, Java supports covariant return types. The overriding method can return any subtype of the superclass method's return type without requiring client-side casting.

Detailed Explanation: A HashSet first computes obj.hashCode() to locate the bucket array index. If hashCode() is not overridden, two logically identical objects will have different default memory-based hash codes and land in different buckets. Consequently, set.contains(identicalObj) returns false, and duplicates accumulate in the set.

1. Declare the class final so it cannot be subclassed.
2. Make all fields private final.
3. Provide no mutator methods (setters).
4. Perform deep defensive copying in the constructor when receiving mutable objects: this.items = new ArrayList<>(items);.
5. Perform defensive copying in accessor methods: return new ArrayList<>(this.items); or return Collections.unmodifiableList(this.items).

public record UserRecord(long id, String email) {
    // Compact constructor for validation
    public UserRecord {
        Objects.requireNonNull(email, "Email cannot be null");
    }
}

Explanation: The compiler automatically generates private final fields, a canonical constructor, public accessors (id(), email()), equals(), hashCode(), and toString() in a single line.

Growth Factor: Approximately 1.5x (50% increase). The calculation is newCapacity = oldCapacity + (oldCapacity >> 1).

Optimization: When the total count of elements is known beforehand, pass the initial capacity to the constructor: new ArrayList<>(10000); to avoid repeated array allocations and memory copying.

Cause: The enhanced for loop creates an Iterator. Directly modifying the list via list.remove() changes modCount without updating the iterator's expectedModCount, triggering the fail-fast check.

Idiomatic Java 8+ Fix:

list.removeIf(s -> s.equals("B")); // Or use iterator.remove() explicitly

Comparable<T>: Defines the natural, default ordering of a class (e.g. String alphabetical or Integer numerical) via compareTo(T o).

Comparator<T>: Defines custom, ad-hoc, or multiple alternate orderings (e.g. sorting Users by age, then by name) via Comparator.comparing(User::getAge).thenComparing(User::getName).

Detailed Explanation: Arrays.asList() does not return a java.util.ArrayList; it returns a private static nested class Arrays$ArrayList that is a fixed-size wrapper backed by the original array. It supports set(), but structural modification operations like add() and remove() throw UnsupportedOperationException. Use new ArrayList<>(Arrays.asList(...)) for a resizable list.

1. List.of() is 100% truly immutable; calling set() throws an exception. Arrays.asList() permits set().
2. List.of() strictly forbids null elements (throws NullPointerException immediately). Arrays.asList() allows nulls.
3. List.of() uses compact, field-based internal representations for small sizes, avoiding array overhead.

Result: Throws java.lang.ClassCastException at runtime upon inserting elements.

Explanation: A TreeSet is backed by a Red-Black tree (TreeMap) which must compare elements to determine placement. If no Comparator is supplied to the TreeSet constructor, it casts elements to Comparable. If the class doesn't implement it, the cast fails.

Detailed Explanation: A PriorityQueue is implemented as a binary min-heap stored in a flat array. The heap invariant only guarantees that parents are smaller than their children—it does not sort sibling nodes. Iterating traverses the raw backing array. To retrieve elements in strict priority order, you must repeatedly call poll() in $O(log N)$ time.

public class InsufficientFundsException extends RuntimeException {
    private static final long serialVersionUID = 1L;

    public InsufficientFundsException(String message) {
        super(message);
    }

    public InsufficientFundsException(String message, Throwable cause) {
        super(message, cause);
    }
}

Output: 2

Detailed Explanation: Returning from a finally block overrides any pending return value or unhandled exception originating in the try or catch block. This is a dangerous anti-pattern (flagged by SonarQube/Checkstyle) because it silently suppresses errors.

Answer: The exception thrown in the finally block propagates to the caller; the original exception thrown in the try block is completely masked and swallowed.

Modern Solution: Use try-with-resources, which preserves the primary exception and attaches the secondary closing exception as a suppressed exception accessible via e.getSuppressed().

Explanation: List<? extends Number> represents a list of some unknown subtype of Number. It could be List<Double> or List<BigDecimal>. Adding an Integer would violate type safety if the underlying list was for Doubles. Therefore, upper-bounded wildcards are read-only (except for adding null).

Detailed Explanation: Arrays in Java are reifiable (they retain exact type information at runtime and perform bounds/type checks). Generics, conversely, are implemented via type erasure (stripped at compile time). If generic arrays were allowed, type safety could be violated without a runtime ArrayStoreException. To create generic collections, use ArrayList<T> or (T[]) Array.newInstance(clazz, size).

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[]{ map.get(complement), i };
        }
        map.put(nums[i], i);
    }
    throw new IllegalArgumentException("No solution found");
}

Complexity: Time $O(N)$, Space $O(N)$.

public int findDuplicate(int[] nums) {
    int slow = nums[0];
    int fast = nums[0];
    // 1. Detect intersection point in cycle
    do {
        slow = nums[slow];
        fast = nums[nums[fast]];
    } while (slow != fast);

    // 2. Find cycle entrance
    slow = nums[0];
    while (slow != fast) {
        slow = nums[slow];
        fast = nums[fast];
    }
    return slow;
}

public boolean isValid(String s) {
    Deque<Character> stack = new ArrayDeque<>();
    for (char c : s.toCharArray()) {
        if (c == '(') stack.push(')');
        else if (c == '{') stack.push('}');
        else if (c == '[') stack.push(']');
        else if (stack.isEmpty() || stack.pop() != c) return false;
    }
    return stack.isEmpty();
}

Note: Always prefer ArrayDeque over the legacy java.util.Stack, which inherits synchronizations and vector locking.

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true); // true = access-order mode
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity; // Evict least recently accessed entry
    }
}

Anonymous Inner Class: this refers to the instance of the anonymous inner class itself.

Lambda Expression: Lambdas are lexically scoped. this refers to the instance of the enclosing class in which the lambda was declared.

public class Service implements A, B {
    @Override
    public void execute() {
        // Explicitly select which interface implementation to delegate to:
        A.super.execute(); // Or B.super.execute(), or write custom logic
    }
}

Flaws: Cloneable is a marker interface that lacks a public clone() method. The default Object.clone() performs an unchecked shallow field-by-field copy without invoking any constructor, bypassing state validation invariants.

Best Practice: Use Copy Constructors: public User(User other) or Static Copy Factory Methods: public static User from(User other).

Result: The JVM wraps the exception in a java.lang.ExceptionInInitializerError.

Consequence: The class fails to load, and subsequent attempts to access the class in the same classloader result in java.lang.NoClassDefFoundError.

public class DatabaseConnection {
    private static volatile DatabaseConnection instance;
    private DatabaseConnection() {}

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

Why volatile is mandatory: Without volatile, the JVM/CPU can reorder instructions during new DatabaseConnection(): allocating memory, assigning the reference to instance, and THEN calling the constructor. Another thread could observe a non-null but partially initialized object!

public enum AppConfig {
    INSTANCE;
    public void loadSettings() { ... }
}

Benefits: 1) Guaranteed thread-safe initialization by the JVM classloader, 2) Immunity against reflection attacks (the JVM prevents reflection-based enum instantiation), 3) Serialization is handled automatically without duplicate instances.

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}

public Order deepCopy() {
    Order copy = new Order(this.orderId);
    for (OrderItem item : this.items) {
        copy.addItem(new OrderItem(item.getProduct(), item.getQuantity()));
    }
    return copy;
}

Explanation: Both the collection container AND every individual mutable element within it must be newly instantiated to ensure modifications to the copy do not corrupt the original object graph.

Detailed Explanation: In Java, methods execute on the thread stack and local variables vanish when the stack frame returns. Lambdas, however, are heap-allocated objects that may execute asynchronously on another thread long after the creating method has exited. Java copies (captures) the variable value into the lambda object. If the variable could be reassigned, the stack variable and heap copy would diverge, leading to dangerous concurrency race conditions and desynchronization.

Output: Stream pipeline built. (Nothing from the filter is printed!)

Detailed Explanation: Streams are strictly lazy. Intermediate operations (like filter and map) do not execute any work until a terminal operation (such as collect(), forEach(), or count()) is invoked on the stream pipeline.

Stream.iterate(new long[]{0, 1}, f -> new long[]{f[1], f[0] + f[1]})
    .map(f -> f[0])
    .filter(n -> n > 0 && n % 2 == 0)
    .limit(5) // Short-circuits the infinite stream
    .forEach(System.out::println);

Explanation: limit(n) is a stateful short-circuiting intermediate operation that closes the stream consumer once $n$ elements pass through, preventing infinite loops.

Map<String, Double> totalByCity = transactions.stream()
    .collect(Collectors.groupingBy(
        Transaction::city,
        Collectors.summingDouble(Transaction::amount)
    ));

Explanation: Collectors.groupingBy accepts a classifier function and a downstream collector that reduces the values associated with each group key in a single pass.

List<String> uniqueWords = nestedList.stream()
    .flatMap(Collection::stream)
    .map(String::toUpperCase)
    .distinct()
    .sorted()
    .collect(Collectors.toList());

Explanation: flatMap takes each child list, transforms it into a Stream<String>, and flattens all child streams into a unified linear stream.

Hazard: By default, all parallel streams across the entire JVM share the common ForkJoinPool.commonPool(), which has worker threads equal to Runtime.getRuntime().availableProcessors() - 1. If threads block on network/disk I/O, the pool becomes saturated (starved), degrading all unrelated parallel tasks sitewide.

ForkJoinPool customPool = new ForkJoinPool(4);
try {
    List<String> result = customPool.submit(() ->
        items.parallelStream()
             .map(this::processHeavyTask)
             .collect(Collectors.toList())
    ).get();
} finally {
    customPool.shutdown();
}

Bug: SimpleDateFormat stores intermediate parsing state in an internal mutable Calendar object. Concurrent threads calling format() or parse() corrupt each other's timestamps or throw random NumberFormatException errors.

Solution: Use Java 8's thread-safe, immutable DateTimeFormatter from java.time.format.

1. Memory Visibility: Writes to a volatile variable are immediately flushed to main memory, and reads always fetch the latest value from main memory (invalidating CPU L1/L2 caches).
2. Instruction Reordering: Establishes a happens-before boundary preventing compiler and CPU reordering across the volatile access.

Does NOT guarantee atomicity: count++ is three operations (read, modify, write). Two threads can read the same value concurrently. Use AtomicInteger for atomicity.

Detailed Explanation: synchronized is a pessimistic lock that incurs operating system kernel context switches, thread suspension, and monitor acquisition overhead. AtomicInteger uses optimistic lock-free hardware instructions known as Compare-And-Swap (CAS) via Unsafe / VarHandle. It attempts the increment in a tight user-space loop without ever suspending the thread.

Object lockA = new Object();
Object lockB = new Object();

// Thread 1:
synchronized(lockA) {
    Thread.sleep(50);
    synchronized(lockB) { ... }
}

// Thread 2 (acquires in reverse order):
synchronized(lockB) {
    Thread.sleep(50);
    synchronized(lockA) { ... }
}

Diagnosis: Capture a JVM thread dump using jstack <pid> or VisualVM. The HotSpot JVM automatically detects cyclic lock wait chains and prints: "Found one Java-level deadlock".

Cause: In web containers, HTTP worker threads are retained in an active thread pool and reused across hundreds of requests. A ThreadLocal variable is referenced via the thread's internal threadLocals map. If code fails to invoke threadLocal.remove() in a finally block, the object remains anchored to the long-lived thread, preventing garbage collection indefinitely.

CompletableFuture<UserProfile> future = CompletableFuture
    .supplyAsync(() -> fetchUser(userId))
    .thenCompose(user -> CompletableFuture.supplyAsync(() -> attachOrders(user)))
    .thenApply(user -> formatProfile(user))
    .exceptionally(ex -> {
        log.error("Fallback triggered", ex);
        return UserProfile.GUEST_PROFILE;
    });

Explanation: Files.readAllLines() reads the entire file into a List<String> in heap memory, instantly triggering OutOfMemoryError on large files. Files.lines() returns a lazy Stream<String> backed by a BufferedReader that reads lines one by one on-demand without loading the full file into memory.

Note: Always wrap Files.lines() in a try-with-resources block to ensure the underlying file channel is closed.

Detailed Explanation: Traditional file-to-socket copying requires 4 context switches and 3 data copies (Disk -> Kernel OS Buffer -> User Space JVM Buffer -> Socket Buffer). FileChannel.transferTo() leverages the operating system's native sendfile() system call, streaming bytes directly from the page cache to the network interface card (NIC) buffer via DMA without ever copying data into JVM user-space memory.

try (Resource res = new Resource()) {
    res.doAction(); // Throws PrimaryException
} catch (Exception e) {
    System.out.println("Primary: " + e.getMessage());
    Throwable[] suppressed = e.getSuppressed();
    for (Throwable t : suppressed) {
        System.out.println("Suppressed closing error: " + t.getMessage());
    }
}

Explanation: Method references are resolved against the single abstract method (SAM) of the target functional interface. Consumer<String>.accept(String) expects exactly one parameter of type String and returns void, allowing the compiler to bind specifically to PrintStream.println(String). If multiple overloads match the parameter types, an explicit lambda or cast is required to resolve ambiguity.

Detailed Explanation: Stream<Integer> creates 10 million distinct Integer objects on the heap, triggering massive memory allocation, reference pointer chasing, and subsequent garbage collection overhead. IntStream is a specialized primitive stream that operates directly on unboxed 32-bit primitive int values stored in CPU registers, with zero object allocation overhead.

1. supplier(): Creates the mutable result container (e.g. StringBuilder::new).
2. accumulator(): Folds an input element into the mutable result container (e.g. StringBuilder::append).
3. combiner(): Merges two partial result containers during parallel processing.
4. finisher(): Transforms the intermediate container into the final return type (e.g. StringBuilder::toString).

1. Timed Lock Acquisition: lock.tryLock(5, TimeUnit.SECONDS) prevents indefinite blocking and avoids deadlocks.
2. Interruptible Locks: lock.lockInterruptibly() allows a waiting thread to be interrupted while waiting for the lock.
3. Fairness Policy: new ReentrantLock(true) grants locks to the longest-waiting thread, eliminating thread starvation.

CountDownLatch: A one-time synchronizer. One or more threads wait until a set of operations complete and count reaches zero. Cannot be reset.

CyclicBarrier: A reusable synchronizer where a fixed group of threads repeatedly wait for each other to reach a common barrier point before proceeding to the next computation phase (e.g. in iterative matrix computations).

WeakReference: An object referenced only by weak references is reclaimed immediately during the next garbage collection cycle (used in WeakHashMap for canonical mappings).

SoftReference: Kept in memory as long as sufficient heap space remains. Cleared by the GC only when the JVM encounters memory pressure before throwing OutOfMemoryError (ideal for in-memory caches).

Mechanism: By enabling JVM flag -XX:+UseStringDeduplication, the G1 collector scans the heap during background collection cycles. When it finds distinct String objects containing identical character sequences, it re-points their internal value[] byte arrays to a single shared byte array, eliminating megabytes of duplicate memory without changing string identity.

public sealed interface Shape permits Circle, Rectangle {}
public final class Circle implements Shape { public double radius; }
public final class Rectangle implements Shape { public double w, h; }

// Exhaustive pattern switch without requiring 'default' branch
double area = switch (shape) {
    case Circle c -> Math.PI * c.radius * c.radius;
    case Rectangle r -> r.w * r.h;
};

Benefit: The compiler verifies that all permitted subclasses are covered, eliminating runtime missing case errors.

public static String formatObject(Object obj) {
    return switch (obj) {
        case null -> "Empty reference";
        case Integer i -> String.format("Int: %d", i);
        case String s when s.length() > 10 -> "Long string: " + s.substring(0, 10);
        case String s -> "Short string: " + s;
        case List<?> l -> "List size: " + l.size();
        default -> obj.toString();
    };
}

Detailed Explanation: Traditional platform threads map 1:1 to OS kernel threads, consuming ~1MB of stack memory each and limiting applications to ~5,000 threads. Virtual threads are lightweight user-mode threads managed by the JVM requiring only a few hundred bytes. When a virtual thread performs blocking I/O (e.g. database query, HTTP call), the JVM unmounts it from its carrier OS thread, allowing the carrier thread to process other tasks.

Cause: Static collections are rooted in the garbage collection root graph (GC Roots). Because the class remains loaded for the lifespan of the JVM, objects added to the list are never freed by the Garbage Collector, eventually triggering an OutOfMemoryError: Java heap space.

Solution: Use bounded circular buffers (like EvictingQueue) or weak reference caches.

Detailed Explanation: Under JLS 17.5, the Java Memory Model enforces a freeze action on all final fields at the exact moment the constructor completes. This establishes a compiler and CPU memory barrier ensuring that any thread observing a reference to the newly constructed object is guaranteed to observe the correctly initialized values of its final fields without requiring locks or volatile variables.

public class TokenBucketRateLimiter {
    private final long capacity;
    private final double refillTokensPerSecond;
    private double availableTokens;
    private long lastRefillTimestamp;

    public TokenBucketRateLimiter(long capacity, double refillRate) {
        this.capacity = capacity;
        this.refillTokensPerSecond = refillRate;
        this.availableTokens = capacity;
        this.lastRefillTimestamp = System.nanoTime();
    }

    public synchronized boolean tryAcquire() {
        refill();
        if (availableTokens >= 1.0) {
            availableTokens -= 1.0;
            return true;
        }
        return false;
    }

    private void refill() {
        long now = System.nanoTime();
        double elapsedSeconds = (now - lastRefillTimestamp) / 1e9;
        availableTokens = Math.min(capacity, availableTokens + elapsedSeconds * refillTokensPerSecond);
        lastRefillTimestamp = now;
    }
}

public class CustomLRUCache<K, V> {
    private static class Node<K, V> {
        K key; V val;
        Node<K, V> prev, next;
        Node(K k, V v) { this.key = k; this.val = v; }
    }

    private final int capacity;
    private final Map<K, Node<K, V>> map = new HashMap<>();
    private final Node<K, V> head = new Node<>(null, null);
    private final Node<K, V> tail = new Node<>(null, null);

    public CustomLRUCache(int cap) {
        this.capacity = cap;
        head.next = tail;
        tail.prev = head;
    }

    public synchronized V get(K key) {
        Node<K, V> node = map.get(key);
        if (node == null) return null;
        moveToHead(node);
        return node.val;
    }

    public synchronized void put(K key, V val) {
        Node<K, V> node = map.get(key);
        if (node != null) {
            node.val = val;
            moveToHead(node);
        } else {
            if (map.size() >= capacity) {
                Node<K, V> lru = tail.prev;
                removeNode(lru);
                map.remove(lru.key);
            }
            Node<K, V> newNode = new Node<>(key, val);
            map.put(key, newNode);
            addNode(newNode);
        }
    }

    private void addNode(Node<K, V> node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(Node<K, V> node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void moveToHead(Node<K, V> node) {
        removeNode(node);
        addNode(node);
    }
}