Java Interview Opps, Collection framework, GC, Comparator - Yash-777/MyWorld GitHub Wiki

🔹 if - else
 * Evaluates boolean expression — any condition
 * Handles ranges, complex conditions, multiple types
 * Goes top to bottom — first match wins
 * else is optional
int marks = 75;

// multiple condition expressions
if (marks >= 90) {
System.out.println("Grade A");
} else if (marks >= 75) {
System.out.println("Grade B");
} else if (marks >= 60) {
System.out.println("Grade C");
} else {
System.out.println("Fail");
}

// complex conditions — switch cannot do this ✅
if (age > 18 && country.equals("India") && !isBanned) {
System.out.println("Eligible");
}

// null check — switch throws NPE on null ✅
if (name != null && name.equals("John")) { }

// range check — switch cannot do this ✅
if (salary >= 50000 && salary <= 100000) { }

🔹 One-line Conditional (Ternary Operator)

// condition ? true : false
int age = 20;
String result = age >= 18 ? "Adult" : "Minor";   // ✅ one line

// nested ternary — avoid, hard to read ⚠️
String grade = marks >= 90 ? "A" : marks >= 75 ? "B" : marks >= 60 ? "C" : "Fail";

// common uses
int max    = a > b ? a : b;
String msg = user != null ? user.getName() : "Guest";
return isValid ? process() : throwError();

🔹 switch
 * Evaluates single variable against constants
 * Cleaner than multiple if-else for fixed values
 * Works with int, char, String, enum — not boolean, long, float
 * Fall-through — without break continues to next case

// Traditional switch — fall-through risk ⚠️
int day = 3;
switch (day) {
    case 1:
        System.out.println("Monday");
        break;          // ⚠️ forget break — falls to next case
    case 2:
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Other");
}

// switch with enum — Best Use Case ✅
// String constants -> String status = "ACTIVE";
enum Status { PENDING, ACTIVE, INACTIVE, BLOCKED }
Status status = Status.ACTIVE;
switch (status) {
    case PENDING:
        System.out.println("Awaiting approval");
        break;
    case ACTIVE:
        System.out.println("User is active");
        break;
    case INACTIVE:
        System.out.println("User inactive");
        break;
    case BLOCKED:
        System.out.println("User blocked");
        break;
}

Encapsulation is the process of binding (wrapping) data members and member functions into a single unit.

Example: A class in Object-Oriented Programming (OOP).
 * Data members should not be directly accessible from outside the class.
 * They are usually declared as private to ❌ restrict direct access.
 * Access to these data members is provided through public methods such as getter and setter methods (or other controlled methods).

Simple Explanation: Encapsulation helps in data hiding and protects data from unauthorized access by allowing controlled interaction through methods.

🔐 Concept in One Line: Encapsulation = Data + Methods packed together like medicine inside a capsule with controlled access.

Class (The Container): `Data Members (Variables)` & `Member Functions (Methods)` 👉 Both are packed into one single unit.
👉 Class   = Capsule 💊
👉 Data    = Medicine inside
👉 Methods = Safe way to use it

 * Same class, same method name, different parameters (type/count/order)
 * Resolved at compile time (Static binding)
 * Return type can be different but alone cannot differentiate overloading
 * Access modifier can be anything — no restriction
 * null → compiler picks most specific type; if tie → compile error
 * @Override annotation not applicable
 * Can be done in same class or child class (child overloading parent method)
 * final, static, private methods all can be overloaded ✅

 * Parent → Child, same method name + same parameters + same return type
 * Resolved at runtime based on object type (Dynamic binding)
 * Animal ref = new Dog() → ref.instanceSound() calls Dog's method
 * @Override annotation recommended — catches mistakes at compile time
 * Return type can be covariant (child can narrow return type — Animal → Dog) ✅
 * Access modifier can only be widened, never narrowed
      private → default → protected → public
              (widening direction →)
 * private methods cannot be overridden — they are invisible to child class
 * final methods cannot be overridden ❌
 * Static Hiding (Parent → Child)
     static methods cannot be overridden — they get hidden instead
 * constructor cannot be overridden
 * Overriding method cannot throw broader checked exceptions than parent
    * Parent throws IOException → Child can throw IOException or narrower ✅
    * Parent throws IOException → Child throws Exception ❌
 * abstract methods must be overridden in concrete child class

/**
 * Comprehensive Polymorphism Demo
 * Covers:
 * - Static method hiding vs Instance method overriding
 * - Static method call via null object
 * - Method overloading with null (String vs Object)
 * - Ambiguous overloading (Integer vs Long)
 * - Covariant return type in overriding
 * - Access modifier rules in override/overload
 */
// ======================== PARENT CLASS ========================
class Animal {

    // 1. STATIC METHOD — will be HIDDEN (not overridden) in child
    static void staticSound() {
        System.out.println("Animal: static sound (Animal class)");
    }

    // 2. INSTANCE METHOD — will be OVERRIDDEN in child
    void instanceSound() {
        System.out.println("Animal: instance sound");
    }

    // 3. OVERLOADING: null call — Object vs String
    void greet(Object o) {
        System.out.println("greet(Object) called");
    }
    void greet(String s) {
        System.out.println("greet(String) called");
    }

    // 4. OVERLOADING: null call — Integer vs Long (AMBIGUOUS)
    void calculate(Integer i) {
        System.out.println("calculate(Integer) called");
    }
    void calculate(Long l) {
        System.out.println("calculate(Long) called");
    }

    // 5. COVARIANT RETURN TYPE — parent returns Animal
    Animal getInstance() {
        System.out.println("Animal getInstance()");
        return new Animal();
    }

    // 6. ACCESS MODIFIER — protected in parent (child can widen it to public)
    protected void accessDemo() {
        System.out.println("Animal: protected accessDemo()");
    }
}

// ======================== CHILD CLASS ========================
class Dog extends Animal {

    // 1a. STATIC METHOD HIDING — not overriding, just hiding
    //     Resolved at COMPILE TIME based on reference type
    static void staticSound() {
        System.out.println("Dog: static sound (Dog class)");
    }

    // 1b. INSTANCE METHOD OVERRIDING — resolved at RUNTIME based on object type
    @Override
    void instanceSound() {
        System.out.println("Dog: instance sound (overridden)");
    }

    // 5. COVARIANT RETURN TYPE — child can return Dog (subtype of Animal)
    //    Valid override — return type is narrowed down
    @Override
    Dog getInstance() {
        System.out.println("Dog getInstance() — covariant return");
        return new Dog();
    }

    // 6. ACCESS MODIFIER — widening protected → public is ALLOWED in override
    //    Narrowing (public → protected) is NOT allowed — compile error
    @Override
    public void accessDemo() {
        System.out.println("Dog: public accessDemo() — widened access modifier");
    }
}

// ======================== MAIN CLASS ========================
public class PolymorphismDemo {

    public static void main(String[] args) {
        System.out.println("========== 1. Static Hiding vs Instance Overriding ==========");
        Animal ref = new Dog(); // Animal reference, Dog object

        // Static method — resolved at COMPILE TIME → Animal's method called (HIDING)
        ref.staticSound();          // Output: Animal: static sound
        Animal.staticSound();       // Output: Animal: static sound
        Dog.staticSound();          // Output: Dog: static sound

        // Instance method — resolved at RUNTIME → Dog's method called (OVERRIDING)
        ref.instanceSound();        // Output: Dog: instance sound

        System.out.println("\n========== 2. Static Method Call via NULL Object ==========");
        Animal nullAnimal = null;
        // No NullPointerException — static methods belong to CLASS not object
        // Compiler replaces nullAnimal.staticSound() → Animal.staticSound()
        nullAnimal.staticSound();   // Output: Animal: static sound ✅

        System.out.println("\n========== 3. Overloading with NULL — Object vs String ==========");
        Animal a = new Animal();
        // String is more specific than Object → compiler picks greet(String)
        a.greet(null);              // Output: greet(String) called ✅
        a.greet((Object) null);     // Output: greet(Object) called — explicit cast

        System.out.println("\n========== 4. Overloading NULL — Integer vs Long (AMBIGUOUS) ==========");
        // a.calculate(null); ❌ COMPILE ERROR
        // Both calculate(Integer) and calculate(Long) match null
        // Neither Integer nor Long is more specific than the other
        // Fix: explicit cast
        a.calculate((Integer) null); // Output: calculate(Integer) called ✅
        a.calculate((Long) null);    // Output: calculate(Long) called ✅
        System.out.println("Note: a.calculate(null) → COMPILE ERROR (ambiguous method call)");

        System.out.println("\n========== 5. Covariant Return Type ==========");
        // Parent reference — getInstance() returns Animal type at compile time
        Animal animalObj = ref.getInstance();   // Runs Dog's getInstance() at runtime
        // Dog reference — can directly get Dog type
        Dog dog = new Dog();
        Dog dogObj = dog.getInstance();         // Dog's covariant return ✅

        System.out.println("\n========== 6. Access Modifier in Override ==========");
        // Dog widened accessDemo() from protected → public
        // Calling via Animal reference still works ✅
        ref.accessDemo();           // Output: Dog: public accessDemo()

        System.out.println("\n========== Summary of Rules ==========");
        System.out.println("Static method    → HIDDEN   (compile-time, reference type decides)");
        System.out.println("Instance method  → OVERRIDDEN (runtime, object type decides)");
        System.out.println("null + static    → No NPE, resolved by compiler to class");
        System.out.println("null + overload  → Most specific type wins; ambiguous = compile error");
        System.out.println("Covariant return → Child can narrow return type (Dog extends Animal)");
        System.out.println("Access modifier  → Override can WIDEN (protected→public) ✅");
        System.out.println("                   Override can NOT NARROW (public→protected) ❌");
        System.out.println("Overload         → Access modifier can be anything, no restriction ✅");
    }
}

========== 1. Static Hiding vs Instance Overriding ==========
Animal: static sound (Animal class)
Animal: static sound (Animal class)
Dog: static sound (Dog class)
Dog: instance sound (overridden)
========== 2. Static Method Call via NULL Object ==========
Animal: static sound (Animal class)
========== 3. Overloading with NULL — Object vs String ==========
greet(String) called
greet(Object) called
========== 4. Overloading NULL — Integer vs Long (AMBIGUOUS) ==========
calculate(Integer) called
calculate(Long) called
Note: a.calculate(null) → COMPILE ERROR (ambiguous method call)
========== 5. Covariant Return Type ==========
Dog getInstance() — covariant return
Dog getInstance() — covariant return
========== 6. Access Modifier in Override ==========
Dog: public accessDemo() — widened access modifier
========== Summary of Rules ==========
Static method    → HIDDEN   (compile-time, reference type decides)
Instance method  → OVERRIDDEN (runtime, object type decides)
null + static    → No NPE, resolved by compiler to class
null + overload  → Most specific type wins; ambiguous = compile error
Covariant return → Child can narrow return type (Dog extends Animal)
Access modifier  → Override can WIDEN (protected→public) ✅
Override can NOT NARROW (public→protected) ❌
Overload         → Access modifier can be anything, no restriction ✅

class Student {
    String name;
    int age;

    @Override
    public boolean equals(Object o) {
        Student s = (Student) o;
        return this.name.equals(s.name) && this.age == s.age;
    }
    // hashCode NOT overridden ❌
}

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

Student s1 = new Student("Alice", 20);
Student s2 = new Student("Alice", 20);

s1.equals(s2); // ✅ true — your custom equals works

Set set = new HashSet<>();
set.add(s1);
set.contains(s2); // ❌ FALSE! Should be true but isn't

Map<Student, String> map = new HashMap<>();
map.put(s1, "Engineer");
map.get(s2); // ❌ returns null! s2 can't find s1's bucket

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
                        JVM MEMORY
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
          new Object()
               │
               ▼
┌────────────────────────────────────── HEAP MEMORY ──────┐
│ ┌─────────────────────────────────────┐                 │
│ │         YOUNG GENERATION            │                 │
│ │                                     │                 │
│ │  ┌──────────────┐  ┌────┐  ┌────┐   │                 │
│ │  │     EDEN     │  │ S0 │  │ S1 │   │                 │
│ │  │              │  │    │  │    │   │                 │
│ │  │  new Object()│  │age │  │age │   │                 │
│ │  │  allocated   │  │ 1  │  │ 2  │   │                 │
│ │  │    here      │  │    │  │    │   │                 │
│ │  └──────┬───────┘  └─┬──┘  └─┬──┘   │                 │
│ │         │    Minor GC│       │      │                 │
│ │         │    ┌───────┘       │      │                 │
│ │         ▼    ▼               │      │                 │
│ │       Eden full?             │      │                 │
│ │       Minor GC runs  ────────┘      │                 │
│ │       survivors move S0 ↔ S1        │                 │
│ │       age counter +1 each cycle     │                 │
│ └──────────────────┬───────────────── ┘                 │
│                    │ age >= threshold (default 15)      │
│                    ▼                                    │
│ ┌───────────────────────────────────────┐               │
│ │           OLD GENERATION              │               │
│ │                                       │               │
│ │   Long lived objects promoted here    │               │
│ │   Large objects directly here         │               │
│ │                                       │               │
│ │   Major GC runs when Old Gen fills up │               │
│ └───────────────────────────────────────┘               │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────── NON-HEAP MEMORY ─────┐
│ ┌─────────────────────────────────────────────────────┐ │
│ │                   METASPACE                         │ │
│ │   (replaced PermGen from Java 8+)                   │ │
│ │   • Class metadata      • Method info               │ │
│ │   • Static variables    • Constants                 │ │
│ │   • Class loaders       • Annotations               │ │
│ │                                                     │ │
│ │   grows dynamically — uses native memory            │ │
│ └─────────────────────────────────────────────────────┘ │
│                                                         │
│ ┌──────────────┐   ┌──────────────┐   ┌───────────────┐ │
│ │  CODE CACHE  │   │    STACK     │   │  NATIVE MEMORY│ │
│ │              │   │              │   │               │ │
│ │ JIT compiled │   │ method calls │   │ direct buffer │ │
│ │ bytecode     │   │ local vars   │   │ OS resources  │ │
│ │              │   │ stack frames │   │               │ │
│ └──────────────┘   └──────────────┘   └───────────────┘ │
└─────────────────────────────────────────────────────────┘
══════════════════════════════════════════════
Object Age — Survivor Threshold
Minor GC 1  →  Object moves Eden  → S0  (age = 1)
Minor GC 2  →  Object moves S0    → S1  (age = 2)
Minor GC 3  →  Object moves S1    → S0  (age = 3)
Minor GC 4  →  Object moves S0    → S1  (age = 4)
...
Minor GC 15 →  age = 15 → PROMOTED to Old Generation
══════════════════════════════════════════════

                    JVM HEAP
══════════════════════════════════════════════
        🟢 YOUNG GENERATION
        ─────────────────────────
         new Object()
               │
               ▼
        ┌─────────────┐
        │    Eden     │  ← Eden full? = NO → stays in Eden
        └─────────────┘
               │  (Eden full → Minor GC)
			   ├──→ Dead objects ─────────→ ♻ GARBAGE COLLECTED
               ▼
		┌──────────────┐
        │ Survivor S0  │ age = 1
        │ Survivor S1  │ age = 2, 3, 4 ... (S0 ↔ S1 each Minor GC)
        └──────────────┘
               │  (Age ≥ Threshold, e.g., 15)
               ▼
══════════════════════════════════════════════
        🔵 OLD GENERATION (Tenured)
──────────────────────────────────────────────
        Long-living objects promoted here
               ├──→ Dead object────────────→ ♻ GARBAGE COLLECTED
               │ (Old Gen fills → Major GC — slow, infrequent)
               ▼
        Mark → Sweep → Compact
		Still not enough memory?
               │
               ▼
  ┌─────────────────────────────────────────┐
  │           FULL GC                       │
  │  Entire Heap + Metaspace cleaned        │
  │  Triggered by JVM or System.gc()        │
  │  Most expensive — Stop The World (STW)  │
  └─────────────────────────────────────────┘
               ├──→ Dead objects  ──────────────────────→ ♻ GARBAGE COLLECTED
               │
               ▼
          Still no memory?
               │
               ▼
          💥 OutOfMemoryError: Java heap space
══════════════════════════════════════════════
Garbage Collected / Removed

static int add(int a, int b)           { return a + b; }
static int add(int a, int b, int c)    { return a + b + c; }  // duplicate!
static int add(int a, int b, int c, int d) { return a + b + c + d; } // more duplicate!

static int add(int... numbers) {        // int... → int[] internally
    int sum = 0;
    for (int n : numbers) sum += n;
    return sum;
}

 * Introduced in Java 8
 * Must have a body
 * Implicitly public
 * NOT inherited by implementing classes
 * Cannot be overridden (belongs to interface only)
 * Called via InterfaceName.method() only
 * Cannot use this keyword
 * Can call private static methods inside interface
 * Purpose — provide utility/helper 
      methods related to interface

 * Introduced in Java 8
 * Must have a body
 * Implicitly public
 * Inherited by implementing classes
 * Can be overridden by implementing classes
 * Can call private methods inside interface
 * Uses this keyword
 * Purpose — provide backward compatibility 
      without breaking old classes

 * Introduced in Java 9
 * Must have a body
 * Explicitly private (must write private)
 * NOT inherited by implementing classes
 * NOT accessible outside interface
 * Cannot be overridden
 * Two types — private and private static
 * private → used by default methods
 * private static → used by static methods
 * Purpose — avoid code duplication inside 
      interface (internal helper)

public class BeforeJava8 {
    public static void main(String[] args) {

        List<String> names = new ArrayList<>();
        names.add("Charlie");
        names.add("Alice");
        names.add("Bob");

        // ❌ Old way — had to use Collections utility class separately
        Collections.sort(names);  // external utility needed
        System.out.println(names); // [Alice, Bob, Charlie]

        // ❌ Old way — custom comparator
        Collections.sort(names, new Comparator() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a); // reverse order
            }
        });
        System.out.println(names); // [Charlie, Bob, Alice]
    }
}

// ─────────────────────────────────────
// ArrayList — Old class, NO changes made
// gets sort() for FREE via default method
// ─────────────────────────────────────
// ✅ New way — sort() directly on List object (Java 8 default method)
names.sort(Comparator.naturalOrder());
System.out.println("Ascending : " + names);  // [Alice, Bob, Charlie]

names.sort(Comparator.reverseOrder());
System.out.println("Descending: " + names);  // [Charlie, Bob, Alice]

// ─────────────────────────────────────
// Custom sort with lambda (Java 8)
// ─────────────────────────────────────
List<String> cities = new ArrayList<>();
cities.add("Mumbai");
cities.add("Delhi");
cities.add("Ahmedabad");
cities.add("Pune");

// sort by string length
cities.sort((a, b) -> a.length() - b.length());
System.out.println("By Length : " + cities);  // [Pune, Delhi, Mumbai, Ahmedabad]

Comparator interface
─────────────────────────────────────────
compare()          ← abstract
naturalOrder()     ← STATIC  ✅  called via Comparator.naturalOrder()
reverseOrder()     ← STATIC  ✅  called via Comparator.reverseOrder()
comparing()        ← STATIC  ✅  called via Comparator.comparing()
─────────────────────────────────────────

public interface Comparator<T> { //actual source (simplified)

    // abstract
    int compare(T o1, T o2);

    // default
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
    default Comparator<T> thenComparing(Comparator<? super T> other) {
        return (c1, c2) -> {
            int res = this.compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

    // static
    static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }
    static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }
    static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor) {
        return (c1, c2) -> keyExtractor.apply(c1)
                          .compareTo(keyExtractor.apply(c2));
    }
}

Collection interface
─────────────────────────────────────────
iterator()         ← abstract
removeIf()         ← DEFAULT  ✅  inherited, can override
clearInvalid()     ← DEFAULT  ✅  inherited, can override
─────────────────────────────────────────

// @since 1.2
public interface List<E> extends Collection<E> {
	//...
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
	default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
}
public interface Collection<E> extends Iterable<E> {

}
// @since 1.5
public interface Iterable<T> {
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
	default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

/*
 * Comparable Interface (java.lang.Comparable)
 *
 * Method:
 *   int compareTo(T o)
 *
 * Key Points:
 * - The object compares itself with another object.
 * - The class must implement Comparable to define natural ordering.
 * - Allows only ONE sorting sequence.
 * - Sorting logic is written inside the class.
 * - Used for natural ordering (default sorting).
 *
 * Common classes that already implement Comparable:
 *   String, Integer, Double, Date, Calendar, etc.
 */

/*
 * Comparator Interface (java.util.Comparator)
 *
 * Method:
 *   int compare(T o1, T o2)
 *
 * Key Points:
 * - Compares TWO different objects externally.
 * - Sorting logic is written in a separate class or lambda.
 * - Allows MULTIPLE sorting sequences.
 * - Useful for customized sorting without modifying the class.
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee implements Comparable {
private int id;
private String name;
private int age;
private long salary;

// Only ONE natural sorting sequence inside the class. Here we sort by id
@Override
public int compareTo(Employee e) {
    if (this.id > e.id) {
        return 1;
    } else if (this.id < e.id) {
        return -1;
    } else {
        return Character.toString(this.name.charAt(0))
                .compareToIgnoreCase(Character.toString(e.name.charAt(0)));
    }
}

// Multiple sorting sequences using Comparator

// Sort by Name
public static Comparator<Employee> nameComparator = new Comparator<Employee>() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.getName().compareTo(e2.getName());
    }
};

// Sort by ID
public static Comparator<Employee> idComparator = new Comparator<Employee>() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return Integer.compare(e1.getId(), e2.getId());
    }
};

public static void main(String[] args) {
    Employee e1 = new Employee(5, "Yash", 22, 1000);
    Employee e2 = new Employee(8, "Tharun", 24, 25000);
    Employee e3 = new Employee(3, "Arun", 21, 15000);

    List<Employee> list = new ArrayList<>();
    list.add(e1);
    list.add(e2);
    list.add(e3);

    // Natural sorting using Comparable
    Collections.sort(list);
    System.out.println("Sort by Comparable (id): " + list);

    // Sorting by name using Comparator
    Collections.sort(list, Employee.nameComparator);
    System.out.println("Sort by Name Comparator: " + list);

    // Sorting by id using Comparator
    Collections.sort(list, Employee.idComparator);
    System.out.println("Sort by ID Comparator: " + list);
}

}

List list1 = Arrays.asList(5, 2, 3, 4, 1);
Collections.sort(list1); // Ascending order (natural sort)
System.out.println("Ascending Order: "+ list1 ); // [1, 2, 3, 4, 5]

List list2 = Arrays.asList(5, 2, 3, 4, 1);
// Descending order using lambda Comparator
Collections.sort(list2, (a, b) -> b - a);
System.out.println("Descending Order:"+ list2 ); // [5, 4, 3, 2, 1]

public static Comparator nameComparator =
        (e1, e2) -> e1.getName().compareTo(e2.getName());
public static Comparator idComparator =
        (e1, e2) -> Integer.compare(e1.getId(), e2.getId());

javaList<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
Iterator<String> iterator = list.iterator();

while (iterator.hasNext()) {
    String item = iterator.next();
    list.add("D"); // Throws ConcurrentModificationException
}
      

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
// Thread 1: Iterating
Thread t1 = new Thread(() -> {
    try {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println("Thread 1: " + iterator.next());
            Thread.sleep(100); // Simulate work
        }
    } catch (ConcurrentModificationException e) {
        System.out.println("Thread 1: ConcurrentModificationException caught!");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
// Thread 2: Modifying (changes modCount)
Thread t2 = new Thread(() -> {
    try {
        Thread.sleep(150);
        //list.add("E"); // Increments modCount
        list.add(4, "E"); // No-Increments modCount - even T1 leads to ConcurrentModificationException
        System.out.println("Thread 2: Added element E");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t1.start();
t2.start();
/* output
Thread 1: A
Thread 1: B
Thread 2: Added element E
Thread 1: ConcurrentModificationException caught!
*/

javaList<String> list = new CopyOnWriteArrayList<>(Arrays.asList("A", "B", "C"));
Iterator<String> iterator = list.iterator();

while (iterator.hasNext()) {
    String item = iterator.next();
    list.add("D"); // No exception - iterator works on snapshot
}
      

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
// Thread 1: Iterating
Thread t1 = new Thread(() -> {
    try {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println("Thread 1: " + iterator.next());
            Thread.sleep(100); // Simulate work
        }
    } catch (ConcurrentModificationException e) {
        System.out.println("Thread 1: ConcurrentModificationException caught!");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
// Thread 2: Modifying (changes modCount)
Thread t2 = new Thread(() -> {
    try {
        Thread.sleep(150);
        list.add("E"); // Increments modCount
        System.out.println("Thread 2: Added element E");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
t1.start();
t2.start();
/* output
Thread 1: A
Thread 1: B
Thread 2: Added element E
Thread 1: C
Thread 1: D
*/

// HashMap - Allows null key and values
Map hashMap = new HashMap<>();
hashMap.put(null, "value1");        // ✅ OK
hashMap.put("key1", null);          // ✅ OK
hashMap.put("key2", null);          // ✅ OK (multiple nulls)
System.out.println(hashMap);
// Output: {null=value1, key1=null, key2=null}
      

// Hashtable - Does NOT allow null key or values
Map hashtable = new Hashtable<>();
hashtable.put(null, "value1");      // ❌ NullPointerException
hashtable.put("key1", null);        // ❌ NullPointerException
      

// ConcurrentHashMap - Does NOT allow null key or values
Map concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put(null, "value1");  // ❌ NullPointerException
concurrentMap.put("key1", null);    // ❌ NullPointerException
      

How it works:
─────────────────────────────────────────
Step 1: key.hashCode()          → generates hash number
Step 2: hash % array.length     → finds bucket index
Step 3: store in that bucket    → LinkedList if collision
Step 4: LinkedList > 8 nodes    → converts to Red-Black Tree
─────────────────────────────────────────
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

System.out.println("=== Iterator (Fail-Fast) ===");
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
    String key = iterator.next();
    System.out.println(key + " = " + map.get(key));
// Modifying during iteration
if (key.equals("A")) {
    map.put("D", 4); // Modifies modCount
}

}
/*
=== Iterator (Fail-Fast) ===
A = 1
Exception in thread "main" java.util.ConcurrentModificationException
*/

Hashtable<String, Integer> table = new Hashtable<String, Integer>() {{
    put("A", 1);
    put("B", 2);
    put("C", 3);
}}; // java 9+ = new Hashtable<>(Map.of("A", 1, "B", 2, "C", 3));

System.out.println("=== Iterator (Fail-Fast) ===");
try {
    Iterator<String> iterator = table.keySet().iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        System.out.println(key);
        if (key.equals("A")) {
            table.put("D", 4); // Throws exception
        }
    }
} catch (ConcurrentModificationException e) {
    System.out.println("Iterator: ConcurrentModificationException!");
}

System.out.println("\n=== Enumeration (NOT Fail-Fast) ===");
Enumeration<String> enumeration = table.keys();
while (enumeration.hasMoreElements()) {
    String key = enumeration.nextElement();
    System.out.println(key);
    if (key.equals("A")) {
        table.put("D", 4); // May cause unpredictable behavior
    }
}
System.out.println("Enumeration completed (no exception)");

/* output
=== Iterator (Fail-Fast) ===
A
Iterator: ConcurrentModificationException!
=== Enumeration (NOT Fail-Fast) ===
A
D
C
B
Enumeration completed (no exception)
*/

Map<String, Integer> map = new ConcurrentHashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

Iterator<String> iterator = map.keySet().iterator();

while (iterator.hasNext()) {
    String key = iterator.next();
    System.out.println(key + " = " + map.get(key));
// Modifying during iteration - NO EXCEPTION
if (key.equals("A")) {
    map.put("D", 4);
    System.out.println("Added D=4 during iteration");
}

}

System.out.println("\nFinal map: " + map);
System.out.println("No exception thrown!");
/*
A = 1
Added D=4 during iteration
B = 2
C = 3
D = 4
Final map: {A=1, B=2, C=3, D=4}
No exception thrown!
*/

public class ThreadSafetyComparison {
    /** Number of CPUS, to place bounds on some sizings */
    static final int NCPU = Runtime.getRuntime().availableProcessors();

    private static final int THREAD_COUNT = 16; //NCPU=12
    private static final int OPERATIONS = 1000;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("THREAD_COUNT :"+THREAD_COUNT);
        System.out.println("=== HashMap (Not Thread-Safe) ===");
        testMap(new HashMap<>());
 
        System.out.println("\n=== Hashtable (Thread-Safe - Synchronized) ===");
        testMap(new Hashtable<>());

        System.out.println("\n=== ConcurrentHashMap (Thread-Safe - Lock Striping) ===");
        testMap(new ConcurrentHashMap<>());
    }
    private static void testMap(Map<Integer, Integer> map) throws InterruptedException {
        long startTime = System.currentTimeMillis();

        Thread[] threads = new Thread[THREAD_COUNT];

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int threadId = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < OPERATIONS; j++) {
                    int key = threadId * OPERATIONS + j;
                    map.put(key, key);
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        long endTime = System.currentTimeMillis();

        System.out.println("Expected size: " + (THREAD_COUNT * OPERATIONS));
        System.out.println("Actual size: " + map.size());
        System.out.println("Time taken: " + (endTime - startTime) + "ms");
        System.out.println("Data consistency: " + 
            (map.size() == THREAD_COUNT * OPERATIONS ? "✅ PASS" : "❌ FAIL"));
    }
}
      

THREAD_COUNT :4
=== HashMap (Not Thread-Safe) ===
Expected size: 4000
Actual size: 3921
Time taken: 24ms
Data consistency: ❌ FAIL
=== Hashtable (Thread-Safe - Synchronized) ===
Expected size: 4000
Actual size: 4000
Time taken: 3ms
Data consistency: ✅ PASS
=== ConcurrentHashMap (Thread-Safe - Lock Striping) ===
Expected size: 4000
Actual size: 4000
Time taken: 8ms
Data consistency: ✅ PASS
      

THREAD_COUNT :12
=== HashMap (Not Thread-Safe) ===
Expected size: 12000
Actual size: 10623
Time taken: 31ms
Data consistency: ❌ FAIL
=== Hashtable (Thread-Safe - Synchronized) ===
Expected size: 12000
Actual size: 12000
Time taken: 15ms
Data consistency: ✅ PASS
=== ConcurrentHashMap (Thread-Safe - Lock Striping) ===
Expected size: 12000
Actual size: 12000
Time taken: 12ms
Data consistency: ✅ PASS
      

THREAD_COUNT :16
=== HashMap (Not Thread-Safe) ===
Expected size: 16000
Actual size: 15293
Time taken: 30ms
Data consistency: ❌ FAIL
=== Hashtable (Thread-Safe - Synchronized) ===
Expected size: 16000
Actual size: 16000
Time taken: 12ms
Data consistency: ✅ PASS
=== ConcurrentHashMap (Thread-Safe - Lock Striping) ===
Expected size: 16000
Actual size: 16000
Time taken: 22ms
Data consistency: ✅ PASS
      

public class ConcurrentMapThreadDemo {
    @AllArgsConstructor
    static class Data {
        int value;
        @Override
        public String toString() {
            return "Data{value=" + value +
                    ", identityHash=" + System.identityHashCode(this) + "}";
        }
    }
static ConcurrentHashMap<String, Data> map = new ConcurrentHashMap<>();

// approximate bucket index (like internal spread)
static int bucketIndex(String key, int tableSize) {
    int h = key.hashCode();
    h ^= (h >>> 16);   // spread hash
    return (tableSize - 1) & h;
}
static void putKey(String key, int value) {
    Data data = new Data(value);
    if ( map.containsKey(key) ) {
        System.err.println(Thread.currentThread().getName() +
                " GET key=" + key + " val=" + map.get(key)
        );
    }
    map.put(key, data);

    int bucket = bucketIndex(key, 16); // default table approx
    System.out.println(
            Thread.currentThread().getName() +
            " PUT key=" + key + " val=" + value +
            " hash=" + key.hashCode() + " bucket=" + bucket +
            " identityHash=" + System.identityHashCode(data)
    );
}

public static void main(String[] args) throws Exception {
    System.out.println("Initial inserting 4 keys\n");
    for (int i = 1; i <= 4; i++) {
        putKey("T1_Key_" + i, i);
    }

    Thread t1 = new Thread(() -> {
        for (int i = 1; i <= 6; i++) {
            //Thread.sleep(3500);
            putKey("T1_Key_" + i, (i * 10));
        }
    }, "Thread-1");

    Thread t2 = new Thread(() -> {
        //for (int i = 6; i >= 1; i--) {
        for (int i = 1; i <= 6; i++) {
            putKey("T1_Key_" + i, (i * 100));
        }
    }, "Thread-2");

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

    System.out.println("\nFinal Map Size = " + map.size());
}

}

Initial inserting 4 keys
main PUT key=T1_Key_1 val=1 hash=-597618225 bucket=14 identityHash=1288141870
main PUT key=T1_Key_2 val=2 hash=-597618224 bucket=1 identityHash=2054881392
main PUT key=T1_Key_3 val=3 hash=-597618223 bucket=0 identityHash=966808741
main PUT key=T1_Key_4 val=4 hash=-597618222 bucket=3 identityHash=1908153060
Thread-1 GET key=T1_Key_1 val=Data{value=1, identityHash=1288141870}
Thread-2 GET key=T1_Key_1 val=Data{value=1, identityHash=1288141870}
Thread-1 PUT key=T1_Key_1 val=10 hash=-597618225 bucket=14 identityHash=1032642556
Thread-2 PUT key=T1_Key_1 val=100 hash=-597618225 bucket=14 identityHash=1195851372
Thread-1 GET key=T1_Key_2 val=Data{value=2, identityHash=2054881392}
Thread-1 PUT key=T1_Key_2 val=20 hash=-597618224 bucket=1 identityHash=860567101
Thread-2 GET key=T1_Key_2 val=Data{value=20, identityHash=860567101}
Thread-1 GET key=T1_Key_3 val=Data{value=3, identityHash=966808741}
Thread-2 PUT key=T1_Key_2 val=200 hash=-597618224 bucket=1 identityHash=1233176820
Thread-1 PUT key=T1_Key_3 val=30 hash=-597618223 bucket=0 identityHash=930395276
Thread-2 GET key=T1_Key_3 val=Data{value=30, identityHash=930395276}
Thread-1 GET key=T1_Key_4 val=Data{value=4, identityHash=1908153060}
Thread-2 PUT key=T1_Key_3 val=300 hash=-597618223 bucket=0 identityHash=1304384796
Thread-2 GET key=T1_Key_4 val=Data{value=40, identityHash=1920351238}
Thread-1 PUT key=T1_Key_4 val=40 hash=-597618222 bucket=3 identityHash=1920351238
Thread-2 PUT key=T1_Key_4 val=400 hash=-597618222 bucket=3 identityHash=146653903
Thread-2 GET key=T1_Key_5 val=Data{value=50, identityHash=702447243}
Thread-1 PUT key=T1_Key_5 val=50 hash=-597618221 bucket=2 identityHash=702447243
Thread-2 PUT key=T1_Key_5 val=500 hash=-597618221 bucket=2 identityHash=1987525098
Thread-1 PUT key=T1_Key_6 val=60 hash=-597618220 bucket=5 identityHash=1129205587
Thread-2 GET key=T1_Key_6 val=Data{value=60, identityHash=1129205587}
Thread-2 PUT key=T1_Key_6 val=600 hash=-597618220 bucket=5 identityHash=964659384
Final Map Size = 6

Even if you use:
if(map.containsKey(key)) {
    map.get(key);
}
map.put(key,value);
another thread may insert between them:
T1 containsKey(K) → false
T2 put(K)
T1 put(K)
So T1 never sees T2's value. This is called a race condition.

Empty bucket → CAS insert
Non-empty bucket → synchronized(head node)

Threads can still update different buckets concurrently.
ConcurrentHashMap

table[]
   │                    Thread behavior:
   ├── bucket0 → Node     Thread1 → bucket2 🔒
   ├── bucket1 → Node     Thread2 → bucket7 🔒
   ├── bucket2 → Node     Thread3 → bucket11 🔒
   └── bucketN        

/** * Java 7 HashMap hash spreading */
static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
/** * Java 8 HashMap hash spreading */
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

/** * Spread hash across segments */
private static int hash(int h) {
    // Spread bits to regularize both segment and index locations,
    // using variant of single-word Wang/Jenkins hash.
    h += (h <<  15) ^ 0xffffcd7d;
    h ^= (h >>> 10);
    h += (h <<   3);
    h ^= (h >>>  6);
    h += (h <<   2) + (h << 14);
    return h ^ (h >>> 16);
}

/** * Fast hash spreading */
static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

// Java 7
int index = (tab.length - 1) & hash;
// table = new Entry[DEFAULT_INITIAL_CAPACITY];
// Java 8
int index = (n - 1) & root.hash; // Node[] tab, TreeNode root

int index = (seg.table.length - 1) & hash;
//
static int indexFor(int h, int length) {
    return h & (length-1);
}

int index = (n - 1) & hash;

 Entry -> Entry -> Entry 

 Entry -> TreeNode 

 HashEntry ↓ HashEntry ↓ HashEntry 

 Node -> Node -> Node 

 TreeNode (Red-Black Tree) 

// Java 7 does NOT support treeification at all.
// Buckets are always linked lists, so there is no TREEIFY_THRESHOLD.
//
// Java8
static final int TREEIFY_THRESHOLD = 8;
if bucket size >= 8
    convert linked list → red-black tree
static final int UNTREEIFY_THRESHOLD = 6; 
When resizing/shrinking:
if bucket size <= 6
    convert tree → linked list
static final int MIN_TREEIFY_CAPACITY = 64;
Important rule: 
More buckets reduces collisions better than building trees
if table size < 64
    DO NOT treeify
    instead resize table

bucket
A → B → C → D → E → F → G → H
          (8 nodes)

table size ≥ 64
↓
convert to

        D
      /   \
     B     F
    / \   / \
   A  C  E   G
                \
                 H

❌ Not supported
// Java 7 does NOT support treeification at all.
// Buckets are always linked lists, so there is no TREEIFY_THRESHOLD.

static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;

 if (size > threshold) resize(); 

// java 7 Treeify Threshold
threshold = (int)(capacity * loadFactor); 

 capacity = 16 loadFactor = 0.75 

 Segment.rehash() 

 sizeCtl 

 1 create new table
 2 rehash all entries
 3 move nodes 

 Segment locked
 Segment resized
 Entries moved 

 ForwardingNode
 nextTable
 transferIndex 

 transient int size; 

 Segment.count 

 baseCount CounterCell[] 

 modCount 

 ConcurrentModificationException 

 Entry TreeNode (Java 8+) 

 HashEntry 

Node           // regular node
TreeNode       // red-black tree node
TreeBin        // tree container
ForwardingNode // during resize
ReservationNode // computeIfAbsent

compute()
computeIfAbsent()
computeIfPresent()
merge() 

compute()
computeIfAbsent()
merge() 

// Single flat bucket array
transient Entry<K,V>[] table;
static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;              // not volatile
    Entry<K,V> next;
    final int hash;
    Entry(int h, K k, V v, Entry<K,V> n) {
        key = k;
        value = v;
        next = n;
        hash = h;
    }
}

// Array of Segments (default 16)
final Segment<K,V>[] segments;
static class Segment<K,V> extends ReentrantLock
              implements Serializable {
    transient volatile HashEntry<K,V>[] table;
    transient int threshold;
    final float loadFactor;
    Segment(float lf, int threshold,
            HashEntry<K,V>[] tab) {
        this.loadFactor = lf;
        this.threshold = threshold;
        this.table = tab;
    }
}
static final class HashEntry<K,V> {
    final int hash;
    final K key;
    volatile V value;     // visibility across threads
    volatile HashEntry<K,V> next;
}

// Flat Node array (similar to HashMap)
// but supports CAS + volatile
transient volatile Node<K,V>[] table;
private transient volatile Node<K,V>[] nextTable;
static class Node<K,V>
implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;
}
// Segment kept only for serialization compatibility
static class Segment<K,V> extends ReentrantLock
            implements Serializable {
    final float loadFactor;
    Segment(float lf) {
        this.loadFactor = lf;
    }
}

// Step 1: hash the key
int hash = hash("apple");
// Step 2: find bucket index
int i = indexFor(hash, table.length);
// Step 3: walk linked list
for (Entry e = table[i];
     e != null; e = e.next) {
    if (e.hash == hash && e.key.equals("apple")) {
        e.value = 1; // overwrite
        return;
    }
}
// Step 4: insert new entry
// ⚠️ NO LOCK (not thread-safe)
table[i] = new Entry(hash, "apple", 1, table[i]);

// Step 1: compute hash
int hash = hash("apple");
// Step 2: find segment
Segment<K,V> seg = segmentFor(hash);
// Step 3: lock that segment only
seg.lock();
try {
int i = indexFor(hash, seg.table.length);
HashEntry e = seg.table[i];
while (e != null) {
if (e.hash == hash && e.key.equals("apple")) {
e.value = 1;
return;
}
e = e.next;
}
seg.table[i] =
new HashEntry(
hash,"apple",1,
seg.table[i]);
} finally {
seg.unlock();
}

// Step 1: spread hash
int hash = spread("apple".hashCode());
// Step 2: find bucket
int i = (n - 1) & hash;
// Step 3: read head node
Node<K,V> f = tabAt(table, i);
if (f == null) {
    // CAS insertion
    casTabAt(table, i, null,
        new Node(hash,"apple",1,null));
} else {
    // lock only head node
    synchronized (f) {
        if (tabAt(table, i) == f) {
            Node e = f;
            while (e.next != null) {
                if (e.hash == hash
                    && e.key.equals("apple")) {
                    e.val = 1;
                    return;
                }
                e = e.next;
            }
            e.next =
            new Node(hash,"apple",1,null);
        }
    }
    // Convert to Tree if bucket >= 8
    treeifyBin(table, i);
}

// HashMap internal Entry structure (Java 7)
static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    final int hash;
    // Creates a new entry
    Entry(int h, K k, V v, Entry<K,V> n) {
        key = k;
        value = v;
        next = n;
        hash = h;
    }
}
// Entry set view
private final class EntrySet
        extends AbstractSet<Map.Entry<K,V>> { }

HashMap<String,Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Banana", 20);
map.put(null, 30);   // HashMap allows null key
System.out.println(map.get("Apple"));

// The segments, each of which is a specialized hash table.
final Segment<K,V>[] segments;
//Segment uses locking mechanism (extends ReentrantLock)
static class Segment<K,V>
        extends ReentrantLock implements Serializable {
    private static final long serialVersionUID =
        2249069246763182397L;
    transient volatile HashEntry<K,V>[] table;
    transient int threshold;
    final float loadFactor;
    Segment(float lf, int threshold,
            HashEntry<K,V>[] tab) {
        this.loadFactor = lf;
        this.threshold = threshold;
        this.table = tab;
    }
}
final class EntrySet
        extends AbstractSet<Map.Entry<K,V>> { }

ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
map.put("Apple", 10);
map.put("Banana", 20);
// map.put(null,30); ❌ throws NullPointerException
// map.put(10,null); ❌ throws NullPointerException

// Segment class retained only for serialization compatibility
static class Segment<K,V>
        extends ReentrantLock implements Serializable {
    private static final long serialVersionUID =
        2249069246763182397L;
    final float loadFactor;
    Segment(float lf) {
        this.loadFactor = lf;
    }
}

/* -------- Node structure -------- */
// Key-value entry (Java 8+)
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;
}
// Main table storing nodes
transient volatile Node<K,V>[] table;
// Used during resizing
private transient volatile Node<K,V>[] nextTable;

ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
map.put("Apple", 10);
map.put("Banana", 20);
// map.put(null,10); ❌ Not allowed
// map.put("Orange", null); ❌ Not allowed

HashMap  = Hash + Map  → key-value  + null key ✅
HashSet  = Hash + Set  → only keys  + null ✅

How it works:
─────────────────────────────────────────
Step 1: key.hashCode()          → generates hash number
Step 2: hash % array.length     → finds bucket index
Step 3: store in that bucket    → LinkedList if collision
Step 4: LinkedList > 8 nodes    → converts to Red-Black Tree
─────────────────────────────────────────
Why HashMap allows null key?

// HashMap handles null key specially:
static final int hash(Object key) {
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// null key always goes to bucket index 0 — special hardcoded handling

TreeMap  = Tree + Map  → key-value  + NO null key ❌
TreeSet  = Tree + Set  → only keys  + NO null ❌

How it works:
─────────────────────────────────────────
Step 1: compare(newKey, rootKey)   → left if smaller, right if bigger
Step 2: insert and auto-balance    → Red-Black Tree rules
Step 3: always maintains sorted order
─────────────────────────────────────────
Why TreeMap/TreeSet doesn't allow null key?

// TreeMap internally does this for every insert:
key.compareTo(anotherKey)

// if key is null:
null.compareTo("Alice")  // ❌ NullPointerException!
// null has no compareTo method — cannot be compared — cannot be placed in tree

Object eligible for GC when:
 * No references pointing to it
 * Reference set to null
 * Reference out of scope
 * Island of isolation (objects pointing to each other but no outside reference)

What causes frequent GC?
 * Too small heap                (-Xmx too low)
 * Memory leak                   (references held unnecessarily)
 * Large object creation         (directly goes to Old Generation)
 * Poor object reuse             (creating new objects in loops)
 * Static references             (held for entire app lifetime)

Finalization (Deprecated Java 9+, Removed Java 18+)
 * finalize() called before GC removes object — unreliable, avoid
 * Use try-with-resources or Cleaner API instead

GC Types
 * Minor GC → cleans Young Generation (Eden + Survivors) — fast, frequent
 * Major GC → cleans Old Generation                      — slow, infrequent
 * Full GC  → cleans Entire Heap + Metaspace             — slowest, STW pause

GC Algorithms (JVM options)
 * Serial GC         → single thread, simple         (-XX:+UseSerialGC)
 * Parallel GC       → multiple threads, throughput  (-XX:+UseParallelGC)
 * G1 GC             → default Java 9+, balanced     (-XX:+UseG1GC)
 * ZGC               → low latency, Java 15+         (-XX:+UseZGC)
 * Shenandoah        → low pause, Java 12+           (-XX:+UseShenandoahGC)

JVM Heap Size Flags
 -Xms → initial heap size        e.g. -Xms256m
 -Xmx → maximum heap size        e.g. -Xmx1024m
 -Xmn → young generation size    e.g. -Xmn256m

import java.lang.ref.*;

Person person = new Person("Alice");

// ─────────────────────────────────────
// 1. STRONG REFERENCE (default)
// ─────────────────────────────────────
// * Never GC'd until explicitly null
// * Normal Java reference
Person strong = new Person("Alice");  // strong reference
strong = null;  // now eligible for GC

// ─────────────────────────────────────
// 2. SOFT REFERENCE (Java 1.2)
// ─────────────────────────────────────
// * GC collects ONLY when JVM runs low on memory
// * Best for: CACHE (image cache, data cache)
SoftReference<Person> soft = new SoftReference<>(new Person("Alice"));

Person s = soft.get(); // returns object if not GC'd yet
if (s == null) {
    // GC already collected it — memory was low
    // reload / recreate object
}

// ─────────────────────────────────────
// 3. WEAK REFERENCE (Java 1.2)
// ─────────────────────────────────────
// * GC collects at NEXT GC cycle regardless of memory
// * Best for: WeakHashMap, listeners, canonicalized mappings
WeakReference<Person> weak = new WeakReference<>(new Person("Alice"));

Person w = weak.get(); // returns object if not yet GC'd
if (w == null) {
    // GC already collected it
}

// WeakHashMap — real use case
// key GC'd automatically when no strong reference to key exists
WeakHashMap<Person, String> map = new WeakHashMap<>();

// ─────────────────────────────────────
// 4. PHANTOM REFERENCE (Java 1.2)
// ─────────────────────────────────────
// * get() always returns NULL — cannot access object
// * Used to know EXACTLY when object is removed from memory
// * Best for: cleanup actions, resource management (Cleaner API)
ReferenceQueue<Person> queue = new ReferenceQueue<>();
PhantomReference<Person> phantom = new PhantomReference<>(new Person("Alice"), queue);

phantom.get(); // always returns null — by design

// when object GC'd → phantom reference enqueued in ReferenceQueue
Reference<?> ref = queue.poll(); // poll to detect cleanup
if (ref != null) {
    // object fully removed from memory — safe to do cleanup
}

Memory pressure increases
         │
         ▼
Strong Reference   → ❌ NEVER collected (unless null)
         │
         ▼
Soft Reference     → ✅ collected when LOW MEMORY
         │
         ▼
Weak Reference     → ✅ collected at NEXT GC cycle
         │
         ▼
Phantom Reference  → ✅ collected AFTER finalization
                      enqueued in ReferenceQueue


Strong  →  I will NEVER let go
Soft    →  Let go only if REALLY needed
Weak    →  Let go at NEXT GC
Phantom →  Already gone — just notify me