Java Interview Questions & Answers

public class PassByValueDemo {
    public static void main(String[] args) {
        int x = 10;
        modifyPrimitive(x);
        System.out.println("Original int after method: " + x); // Output: 10

        StringBuilder sb = new StringBuilder("Original");
        modifyObject(sb);
        System.out.println("Original object after method: " + sb); // Output: Original Modified
    }

    public static void modifyPrimitive(int num) {
        num = 20; // Changes local copy, original 'x' is unaffected
    }

    public static void modifyObject(StringBuilder obj) {
        obj.append(" Modified"); // Changes the object content, visible to original 'sb'
        // obj = new StringBuilder("New Object"); // This would not affect the original reference 'sb'
    }
}

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);      // false (different objects)
System.out.println(s1.equals(s2)); // true (same content)

class Animal { void eat() {} }
class Dog extends Animal {
    void eat(String food) {} // Overloading (different parameter list)
    @Override void eat() {} // Overriding (same signature as superclass method)
}

final int MAX_VALUE = 100;
// MAX_VALUE = 200; // Compile-time error: cannot assign a value to a final variable

final class ImmutableClass {
    // This class cannot be extended
}
// class SubClass extends ImmutableClass {} // Compile-time error

class Parent { final void display() {} }
class Child extends Parent {
    // @Override void display() {} // Compile-time error: cannot override final method
}

abstract class Shape {
    abstract void draw(); // Abstract method
    void printColor() { System.out.println("Color"); } // Concrete method
}

interface Drawable {
    void draw(); // Implicitly public abstract
    default void resize() { System.out.println("Resizing"); } // Java 8 default method
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

List<String> arrayList = new ArrayList<>();       // Good for random access, poor for middle insertions/deletions
List<String> linkedList = new LinkedList<>();     // Poor for random access, good for insertions/deletions at ends/middle

class MyClass {
    static int count = 0; // Static variable

    static {
        System.out.println("Static block executed.");
        count = 10;
    }

    static void displayCount() { // Static method
        System.out.println("Count: " + count);
    }

    class InnerClass { /* non-static nested class */ }
    static class StaticNestedClass { /* static nested class */ }
}

// Usage:
// MyClass.displayCount(); // Calls static method without object
// System.out.println(MyClass.count); // Access static variable directly

import java.io.FileReader;
import java.io.IOException;

class ExceptionDemo {
    // Checked exception: Must be handled or declared
    void readFile(String path) throws IOException {
        FileReader reader = new FileReader(path);
        // ... read from reader ...
        reader.close();
    }

    // Unchecked exception: No compiler enforcement
    void divide(int a, int b) {
        if (b == 0) {
            // Typically, fix the logic to avoid division by zero
            // rather than catching ArithmeticException
        }
        int result = a / b; // ArithmeticException possible at runtime
        System.out.println(result);
    }

    public static void main(String[] args) {
        ExceptionDemo demo = new ExceptionDemo();
        try {
            demo.readFile("nonexistent.txt");
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
        demo.divide(10, 0); // Will throw unchecked ArithmeticException
    }
}

import java.util.ArrayList;
import java.util.List;

public class WrapperClassDemo {
    public static void main(String[] args) {
        // Autoboxing: int primitive to Integer object
        Integer i = 100;
        System.out.println("Autoboxed Integer: " + i);

        // Unboxing: Integer object to int primitive
        int j = i;
        System.out.println("Unboxed int: " + j);

        // Usage in Collections (requires objects)
        List<Integer> numbers = new ArrayList<>();
        numbers.add(50); // Autoboxing: 50 (int) -> new Integer(50)
        int firstNum = numbers.get(0); // Unboxing: Integer(50) -> 50 (int)
        System.out.println("Number from list: " + firstNum);

        // Utility method
        String str = "123";
        int parsedInt = Integer.parseInt(str);
        System.out.println("Parsed int: " + parsedInt);
    }
}

final class MyImmutableClass {
    private final int value;
    private final String name;
    private final MyMutableObject mutableObject; // Example of a mutable field

    public MyImmutableClass(int value, String name, MyMutableObject mutableObject) {
        this.value = value;
        this.name = name;
        // Defensive copy for mutable objects
        this.mutableObject = new MyMutableObject(mutableObject.getData());
    }

    public int getValue() { return value; }
    public String getName() { return name; }
    public MyMutableObject getMutableObject() {
        // Return a defensive copy to prevent external modification
        return new MyMutableObject(this.mutableObject.getData());
    }
}

class MyMutableObject {
    private String data;
    public MyMutableObject(String data) { this.data = data; }
    public String getData() { return data; }
    public void setData(String data) { this.data = data; }
}

interface MyInterface {
    int MY_CONSTANT = 100; // public static final by default
    void doSomething(); // public abstract by default
    default void log(String msg) { System.out.println(msg); }
}

abstract class MyAbstractClass {
    String name; // Can have non-final instance variables
    public MyAbstractClass(String name) { this.name = name; } // Can have constructor
    abstract void doAnotherThing(); // Abstract method
    void commonMethod() { System.out.println("Common implementation"); } // Concrete method
}

class ConcreteClass extends MyAbstractClass implements MyInterface {
    public ConcreteClass(String name) { super(name); }
    @Override public void doSomething() { System.out.println("Implementing interface method"); }
    @Override public void doAnotherThing() { System.out.println("Implementing abstract class method"); }
}

import java.util.Objects;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);
        Person p3 = new Person("Bob", 25);

        System.out.println(p1.equals(p2)); // true
        System.out.println(p1.hashCode() == p2.hashCode()); // true (due to contract)
        System.out.println(p1.equals(p3)); // false
        System.out.println(p1.hashCode() == p3.hashCode()); // false (good distribution)
    }
}

import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

class User implements Serializable {
    String username;
    transient String password; // This field will not be serialized
    int age;

    public User(String username, String password, int age) {
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public String toString() {
        return "User{username='" + username + "', password='" + password + "', age=" + age + "}";
    }

    public static void main(String[] args) {
        User user = new User("john.doe", "secret123", 30);
        System.out.println("Before serialization: " + user);

        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
            oos.writeObject(user);
            System.out.println("User object serialized.");
        } catch (Exception e) {
            e.printStackTrace();
        }

        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
            User deserializedUser = (User) ois.readObject();
            System.out.println("After deserialization: " + deserializedUser); // password will be null
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class MyRunnable implements Runnable {
    private String taskName;
    public MyRunnable(String taskName) { this.taskName = taskName; }
    @Override
    public void run() {
        System.out.println(taskName + " is running in thread: " + Thread.currentThread().getName());
        try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        System.out.println(taskName + " finished.");
    }
}

class MyThread extends Thread {
    private String taskName;
    public MyThread(String taskName) { this.taskName = taskName; }
    @Override
    public void run() {
        System.out.println(taskName + " is running in thread: " + Thread.currentThread().getName());
    }
}

public class ThreadCreationDemo {
    public static void main(String[] args) throws InterruptedException {
        // Using Runnable interface
        Thread thread1 = new Thread(new MyRunnable("Runnable Task"), "RunnableThread-1");
        thread1.start();

        // Extending Thread class
        MyThread thread2 = new MyThread("Thread Class Task");
        thread2.setName("MyThread-2");
        thread2.start();

        thread1.join(); // Wait for thread1 to finish
        thread2.join(); // Wait for thread2 to finish
        System.out.println("Main thread finished.");
    }
}

class Counter {
    private int count = 0;

    // Synchronized method: lock on 'this' (the Counter instance)
    public synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " increments to: " + count);
    }

    // Synchronized block: lock on 'this'
    public void decrement() {
        synchronized (this) {
            count--;
            System.out.println(Thread.currentThread().getName() + " decrements to: " + count);
        }
    }

    public int getCount() { return count; }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
                counter.decrement();
            }
        };

        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount()); // Should be 0
    }
}

import java.util.ArrayList;
import java.util.List;

public class GenericsDemo {
    public static void main(String[] args) {
        // Without generics (raw type) - requires casting, prone to ClassCastException
        List rawList = new ArrayList();
        rawList.add("hello");
        rawList.add(123); // Can add any object
        String s1 = (String) rawList.get(0);
        // String s2 = (String) rawList.get(1); // Runtime ClassCastException

        // With generics - compile-time type safety, no casting needed
        List<String> names = new ArrayList<>(); // Type parameter String
        names.add("Alice");
        names.add("Bob");
        // names.add(123); // Compile-time error: type mismatch

        String name = names.get(0); // No cast needed
        System.out.println(name);

        // Generic method example
        printList(names);
    }

    public static <T> void printList(List<T> list) {
        for (T element : list) {
            System.out.println(element);
        }
    }
}

import java.util.ArrayList;
import java.util.List;

public class AutoboxingUnboxingDemo {
    public static void main(String[] args) {
        // Autoboxing: int primitive to Integer object
        Integer i = 100; // Compiler converts 100 (int) to new Integer(100)
        System.out.println("Autoboxed Integer: " + i);

        // Unboxing: Integer object to int primitive
        int j = i;       // Compiler converts i (Integer) to i.intValue() (int)
        System.out.println("Unboxed int: " + j);

        // Autoboxing in method calls
        printInteger(200); // int 200 is autoboxed to Integer

        // Unboxing with null can cause NullPointerException
        Integer nullInteger = null;
        try {
            // int k = nullInteger; // This would throw NullPointerException at runtime
            System.out.println("Attempting to unbox null...");
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException during unboxing.");
        }

        // Autoboxing in collections
        List<Integer> list = new ArrayList<>();
        list.add(50); // Autoboxing: 50 (int) -> Integer(50)
        int value = list.get(0); // Unboxing: Integer(50) -> 50 (int)
        System.out.println("Value from list: " + value);
    }

    public static void printInteger(Integer num) {
        System.out.println("Received Integer object: " + num);
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesDemo {
    public static void main(String[] args) {
        // Example of try-with-resources with a single resource
        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }

        // Example with multiple resources (separated by semicolon)
        try (FileReader fr = new FileReader("input.txt");
             BufferedReader br = new BufferedReader(fr)) {
            System.out.println("Reading from multiple resources...");
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("Error with multiple resources: " + e.getMessage());
        }
    }
}

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapComparisonDemo {
    public static void main(String[] args) {
        System.out.println("HashMap (No guaranteed order):");
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Apple", 1);
        hashMap.put("Banana", 2);
        hashMap.put("Cherry", 3);
        System.out.println(hashMap); // Order may vary

        System.out.println("\nLinkedHashMap (Insertion order):");
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("Apple", 1);
        linkedHashMap.put("Banana", 2);
        linkedHashMap.put("Cherry", 3);
        System.out.println(linkedHashMap); // Preserves insertion order

        System.out.println("\nTreeMap (Sorted order):");
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Apple", 1);
        treeMap.put("Banana", 2);
        treeMap.put("Cherry", 3);
        System.out.println(treeMap); // Sorted by key
    }
}

import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class Java8FeaturesDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 1. Lambda Expressions and Stream API
        List<String> filteredNames = names.stream()
                                          .filter(name -> name.startsWith("A")) // Lambda in filter
                                          .map(String::toUpperCase) // Method reference in map
                                          .collect(Collectors.toList());
        System.out.println("Filtered & Mapped: " + filteredNames); // Output: [ALICE]

        // 2. ForEach with Lambda
        names.forEach(name -> System.out.println("Hello, " + name));

        // 3. Date and Time API
        LocalDate today = LocalDate.now();
        System.out.println("Today's date: " + today);

        // 4. Optional Class
        Optional<String> optionalName = Optional.ofNullable("Eve");
        optionalName.ifPresent(n -> System.out.println("Optional value: " + n));
        String defaultName = Optional.empty().orElse("Guest");
        System.out.println("Default name: " + defaultName);
    }
}

public class TryCatchFinallyDemo {
    public static void main(String[] args) {
        System.out.println("Scenario 1: No exception in try");
        try {
            System.out.println("Inside try block (no exception).");
        } catch (ArithmeticException e) {
            System.out.println("Inside catch block.");
        } finally {
            System.out.println("Inside finally block (no exception).");
        }

        System.out.println("\nScenario 2: Exception in try, caught by catch");
        try {
            System.out.println("Inside try block (throwing exception).");
            int result = 10 / 0; // Throws ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Inside catch block: " + e.getMessage());
        } finally {
            System.out.println("Inside finally block (after catch).");
        }

        System.out.println("\nScenario 3: Exception in try, not caught, then exception in finally");
        try {
            System.out.println("Inside try block (throwing IOException).");
            throw new java.io.IOException("Original IO Error");
        } catch (ArithmeticException e) {
            System.out.println("Inside catch block (won't execute).");
        } finally {
            System.out.println("Inside finally block (throwing new exception).");
            // This new exception will mask the original IOException
            throw new RuntimeException("Finally block error");
        }
    }
}

public class VolatileDemo {
    private volatile boolean flag = false; // Ensures visibility of 'flag' changes

    public void setFlag() {
        flag = true; // Write to volatile variable
        System.out.println(Thread.currentThread().getName() + " set flag to true.");
    }

    public void waitForFlag() {
        System.out.println(Thread.currentThread().getName() + " waiting for flag to be true...");
        // Loop until 'flag' becomes true. Without volatile, this might spin indefinitely
        // if the compiler optimizes 'flag' to a local register or cache.
        while (!flag) {
            // busy-wait
        }
        System.out.println(Thread.currentThread().getName() + " detected flag is true!");
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileDemo demo = new VolatileDemo();

        Thread readerThread = new Thread(demo::waitForFlag, "ReaderThread");
        Thread writerThread = new Thread(() -> {
            try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            demo.setFlag();
        }, "WriterThread");

        readerThread.start();
        writerThread.start();

        readerThread.join();
        writerThread.join();
        System.out.println("Main thread finished.");
    }
}

import java.io.*;

// Method 1: Do not implement Serializable
class NonSerializableClass {
    String data;
    public NonSerializableClass(String data) { this.data = data; }
    public String toString() { return "NonSerializableClass{data='" + data + "'}"; }
}

// Method 2: Implement Serializable, but throw exception in custom methods
class MyClassPreventSerialization implements Serializable {
    private String secretData;

    public MyClassPreventSerialization(String secretData) {
        this.secretData = secretData;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        throw new NotSerializableException("This class is explicitly not serializable!");
    }

    private void readObject(ObjectInputStream in) throws IOException {
        throw new NotSerializableException("This class is explicitly not deserializable!");
    }

    public String toString() { return "MyClassPreventSerialization{secretData='" + secretData + "'}"; }
}

public class PreventSerializationDemo {
    public static void main(String[] args) {
        // Demo for Method 1
        NonSerializableClass obj1 = new NonSerializableClass("Sensitive Info");
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj1.ser"))) {
            oos.writeObject(obj1);
            System.out.println("Attempted to serialize NonSerializableClass (will fail).");
        } catch (NotSerializableException e) {
            System.out.println("Caught expected error for NonSerializableClass: " + e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Demo for Method 2
        MyClassPreventSerialization obj2 = new MyClassPreventSerialization("Another Secret");
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj2.ser"))) {
            oos.writeObject(obj2);
            System.out.println("Attempted to serialize MyClassPreventSerialization (will fail).");
        } catch (NotSerializableException e) {
            System.out.println("Caught expected error for MyClassPreventSerialization: " + e.getMessage());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class BarrierComparisonDemo {
    public static void main(String[] args) throws InterruptedException {
        // --- CountDownLatch Demo ---
        System.out.println("\n--- CountDownLatch Demo ---");
        CountDownLatch latch = new CountDownLatch(3); // Main thread waits for 3 tasks
        ExecutorService executorForLatch = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 3; i++) {
            int taskId = i + 1;
            executorForLatch.submit(() -> {
                try { Thread.sleep((long) (Math.random() * 1000)); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                System.out.println("Task " + taskId + " finished. Count: " + latch.getCount());
                latch.countDown(); // Decrement count
            });
        }
        latch.await(); // Main thread waits until count is zero
        System.out.println("Main thread released by CountDownLatch. All tasks completed.");
        executorForLatch.shutdown();

        // --- CyclicBarrier Demo ---
        System.out.println("\n--- CyclicBarrier Demo ---");
        // Barrier action runs when all 3 parties arrive
        Runnable barrierAction = () -> System.out.println("--- All parties arrived at barrier! ---");
        CyclicBarrier barrier = new CyclicBarrier(3, barrierAction);
        ExecutorService executorForBarrier = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 6; i++) { // 6 tasks, so barrier will be tripped twice
            int participantId = i + 1;
            executorForBarrier.submit(() -> {
                try {
                    System.out.println("Participant " + participantId + " arrived at barrier.");
                    barrier.await(); // Wait for other participants
                    System.out.println("Participant " + participantId + " passed barrier.");
                } catch (Exception e) {
                    System.err.println("Participant " + participantId + " interrupted: " + e.getMessage());
                }
            });
        }
        executorForBarrier.shutdown();
        executorForBarrier.awaitTermination(1, java.util.concurrent.TimeUnit.SECONDS);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo {
    public static void main(String[] args) throws Exception {
        // Create a fixed thread pool with 2 threads
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // Submit a Runnable task
        executor.submit(() -> {
            System.out.println("Task 1 executed by: " + Thread.currentThread().getName());
            try { Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });

        // Submit a Callable task (can return a result and throw exceptions)
        Future<Integer> future = executor.submit(() -> {
            System.out.println("Task 2 executed by: " + Thread.currentThread().getName());
            try { Thread.sleep(300); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            return 123;
        });

        // Submit another Runnable task (will be queued until a thread is free)
        executor.submit(() -> {
            System.out.println("Task 3 executed by: " + Thread.currentThread().getName());
        });

        System.out.println("Result from Task 2: " + future.get()); // Blocks until Task 2 completes

        // Shut down the executor. It will stop accepting new tasks and finish existing ones.
        executor.shutdown();
        // Optionally, wait for all tasks to complete within a timeout
        if (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
            System.err.println("Executor did not terminate in time.");
            executor.shutdownNow(); // Force shutdown
        }
        System.out.println("All tasks submitted to thread pool.");
    }
}

import java.util.ArrayList;
import java.util.List;

public class TypeErasureDemo {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        List<Integer> integers = new ArrayList<>();

        System.out.println(strings.getClass() == integers.getClass()); // Output: true
        // At runtime, both are just 'java.util.ArrayList' due to type erasure.

        // Cannot use instanceof with parameterized types (compile-time error)
        // if (strings instanceof List<String>) { /* ... */ }

        // Cannot create arrays of generic types (compile-time error)
        // List<String>[] arrayOfLists = new List<String>[10];
    }

    // Bridge method example (conceptual, compiler generates this)
    // interface GenericInterface<T> { void setValue(T value); }
    // class StringImpl implements GenericInterface<String> {
    //    public void setValue(String value) { /* ... */ }
    //    // Compiler might generate a bridge method:
    //    // public void setValue(Object value) { setValue((String) value); }
    // }
}

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

public class ReferenceTypesDemo {
    public static void main(String[] args) {
        // 1. Strong Reference
        String strongRef = new String("Strong"); // Object "Strong" is strongly reachable
        System.out.println("Strong Reference: " + strongRef);

        // 2. Soft Reference
        SoftReference<String> softRef = new SoftReference<>(new String("Soft"));
        System.out.println("Soft Reference (before GC): " + softRef.get());
        // System.gc(); // Hint to GC (not guaranteed to run)
        // If memory runs low, softRef.get() might return null

        // 3. Weak Reference
        WeakReference<String> weakRef = new WeakReference<>(new String("Weak"));
        System.out.println("Weak Reference (before GC): " + weakRef.get());
        System.gc(); // Request GC, likely clears weak reference
        try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        System.out.println("Weak Reference (after GC): " + weakRef.get()); // Likely null

        // 4. Phantom Reference (requires a ReferenceQueue for notification)
        ReferenceQueue<String> refQueue = new ReferenceQueue<>();
        String phantomTarget = new String("Phantom");
        PhantomReference<String> phantomRef = new PhantomReference<>(phantomTarget, refQueue);
        System.out.println("Phantom Reference: " + phantomRef.get()); // Always null

        phantomTarget = null; // Remove strong reference to make object eligible for GC
        System.gc();
        try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }

        // Check if the phantom reference has been enqueued (object has been finalized but not yet reclaimed)
        if (refQueue.poll() == phantomRef) {
            System.out.println("Phantom reference enqueued. Object is ready for post-mortem cleanup.");
        } else {
            System.out.println("Phantom reference not yet enqueued or object not collected.");
        }
    }
}

import java.util.concurrent.*;

public class CompletableFutureVsFuture {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // --- Using Future (blocking) ---
        System.out.println("\n--- Using Future ---");
        Future<String> future = executor.submit(() -> {
            System.out.println("Future task running...");
            Thread.sleep(500);
            return "Hello from Future!";
        });

        System.out.println("Main thread doing other work...");
        // String result = future.get(); // This line blocks the main thread
        // System.out.println("Future result: " + result);

        // --- Using CompletableFuture (non-blocking, reactive) ---
        System.out.println("\n--- Using CompletableFuture ---");
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("CompletableFuture task running...");
            try { Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            return "Hello from CompletableFuture!";
        }, executor);

        completableFuture
            .thenApply(s -> s + " Processed.") // Chain a transformation
            .thenAccept(s -> System.out.println("CompletableFuture result: " + s)) // Consume the result
            .exceptionally(ex -> {
                System.err.println("Error: " + ex.getMessage());
                return null;
            }); // Handle exceptions

        System.out.println("Main thread doing other work while CompletableFuture processes...");

        // Wait for CompletableFuture to complete (for demo purposes, not usually needed in reactive flows)
        completableFuture.join();

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);
    }
}

import java.util.function.Predicate;
import java.util.function.Consumer;

// Custom functional interface (annotated for compile-time check)
@FunctionalInterface
interface MyCalculator {
    int calculate(int a, int b);
    // default void log(String msg) { System.out.println(msg); } // Default methods allowed
}

public class FunctionalInterfaceLambdaDemo {
    public static void main(String[] args) {
        // Using a custom functional interface with a lambda expression
        MyCalculator adder = (x, y) -> x + y;
        System.out.println("Sum: " + adder.calculate(5, 3)); // Output: Sum: 8

        MyCalculator multiplier = (x, y) -> x * y;
        System.out.println("Product: " + multiplier.calculate(5, 3)); // Output: Product: 15

        // Using a built-in functional interface (Predicate) with lambda
        Predicate<String> startsWithA = s -> s.startsWith("A");
        System.out.println("'Apple' starts with A: " + startsWithA.test("Apple")); // Output: true
        System.out.println("'Banana' starts with A: " + startsWithA.test("Banana")); // Output: false

        // Using a built-in functional interface (Consumer) with lambda
        Consumer<String> greeter = name -> System.out.println("Hello, " + name + "!");
        greeter.accept("Alice"); // Output: Hello, Alice!
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamAPIDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Example 1: Filter even numbers, double them, and sum them
        int sumOfDoubledEvens = numbers.stream()
                                     .filter(n -> n % 2 == 0) // Intermediate operation: filters even numbers
                                     .mapToInt(n -> n * 2)   // Intermediate operation: doubles each number
                                     .sum();                 // Terminal operation: sums the results
        System.out.println("Sum of doubled even numbers: " + sumOfDoubledEvens); // Output: 60 (2*2 + 4*2 + 6*2 + 8*2 + 10*2)

        // Example 2: Collect names starting with 'A' into a new List
        List<String> names = Arrays.asList("Alice", "Bob", "Anna", "Charlie", "Andrew");
        List<String> namesStartingWithA = names.stream()
                                               .filter(s -> s.startsWith("A"))
                                               .collect(Collectors.toList()); // Terminal operation: collects to a List
        System.out.println("Names starting with 'A': " + namesStartingWithA);

        // Example 3: Parallel stream for potentially faster processing
        long count = numbers.parallelStream()
                             .filter(n -> n > 5)
                             .count(); // Terminal operation
        System.out.println("Count of numbers greater than 5: " + count);
    }
}

import java.util.Optional;

public class OptionalDemo {
    public static Optional<String> findUserNameById(int id) {
        if (id == 1) {
            return Optional.of("Alice");
        } else if (id == 2) {
            return Optional.ofNullable(null); // Explicitly creating an empty Optional from null
        } else {
            return Optional.empty(); // No user found
        }
    }

    public static void main(String[] args) {
        // Case 1: Value is present
        Optional<String> user1 = findUserNameById(1);
        String name1 = user1.orElse("Default User");
        System.out.println("User 1: " + name1); // Output: User 1: Alice
        user1.ifPresent(s -> System.out.println("Hello, " + s + "!"));

        // Case 2: Value is null (handled as empty Optional)
        Optional<String> user2 = findUserNameById(2);
        String name2 = user2.orElseGet(() -> "Generated Default");
        System.out.println("User 2: " + name2); // Output: User 2: Generated Default

        // Case 3: Value is absent
        Optional<String> user3 = findUserNameById(3);
        try {
            String name3 = user3.orElseThrow(() -> new IllegalArgumentException("User not found!"));
            System.out.println("User 3: " + name3);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage()); // Output: User not found!
        }

        // Chaining operations with map and filter
        Optional<String> adminUser = Optional.of("Admin");
        adminUser.filter(s -> s.equals("Admin"))
                 .map(String::toLowerCase)
                 .ifPresent(s -> System.out.println("Admin user found: " + s)); // Output: Admin user found: admin

        Optional<String> guestUser = Optional.of("Guest");
        guestUser.filter(s -> s.equals("Admin"))
                 .map(String::toLowerCase)
                 .ifPresent(s -> System.out.println("Admin user found: " + s)); // No output
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class FailFastFailSafeDemo {
    public static void main(String[] args) {
        // --- Fail-Fast Iterator Demo (ArrayList) ---
        System.out.println("\n--- Fail-Fast Iterator Demo ---");
        List<String> failFastList = new ArrayList<>(Arrays.asList("A", "B", "C"));
        Iterator<String> failFastIterator = failFastList.iterator();

        while (failFastIterator.hasNext()) {
            String element = failFastIterator.next();
            System.out.println("Reading fail-fast: " + element);
            if (element.equals("B")) {
                // This structural modification will cause ConcurrentModificationException
                // if the iterator tries to access the next element
                // failFastList.add("D"); // Throws ConcurrentModificationException
                // failFastList.remove("A"); // Throws ConcurrentModificationException
                // To remove safely using fail-fast iterator:
                // failFastIterator.remove(); // This is allowed
            }
        }
        // To demonstrate the exception, uncomment the failFastList.add("D") line above.
        // try {
        //     for (String s : failFastList) { // Enhanced for loop uses iterator internally
        //         System.out.println("Reading in loop: " + s);
        //         if (s.equals("B")) failFastList.add("D");
        //     }
        // } catch (java.util.ConcurrentModificationException e) {
        //     System.err.println("Caught expected ConcurrentModificationException: " + e.getMessage());
        // }

        // --- Fail-Safe Iterator Demo (CopyOnWriteArrayList) ---
        System.out.println("\n--- Fail-Safe Iterator Demo ---");
        List<String> failSafeList = new CopyOnWriteArrayList<>(Arrays.asList("X", "Y", "Z"));
        Iterator<String> failSafeIterator = failSafeList.iterator();

        while (failSafeIterator.hasNext()) {
            String element = failSafeIterator.next();
            System.out.println("Reading fail-safe: " + element);
            if (element.equals("Y")) {
                // This structural modification will NOT cause an exception
                // but the added element 'W' will NOT be seen by this iterator instance.
                failSafeList.add("W");
                System.out.println("Added 'W' to fail-safe list.");
            }
        }
        System.out.println("Fail-safe iteration finished.");
        System.out.println("Original fail-safe list after iteration: " + failSafeList); // 'W' is present in the list
    }
}