Collections

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

public class ArrayListExample {
    public static void main(String[] args) {
        // Program to interface: declare as List, instantiate as ArrayList
        List<String> languages = new ArrayList<>();

        // Adding elements
        languages.add("Java");
        languages.add("Python");
        languages.add("JavaScript");
        languages.add("Go");
        languages.add("Java"); // Duplicates are allowed
        System.out.println("Languages: " + languages);
        // Output: Languages: [Java, Python, JavaScript, Go, Java]

        // Access by index
        String first = languages.get(0);
        System.out.println("First: " + first); // Output: First: Java

        // Update an element
        languages.set(3, "Rust");
        System.out.println("After set(3): " + languages);
        // Output: After set(3): [Java, Python, JavaScript, Rust, Java]

        // Insert at specific position
        languages.add(1, "TypeScript");
        System.out.println("After add(1): " + languages);
        // Output: After add(1): [Java, TypeScript, Python, JavaScript, Rust, Java]

        // Remove by index
        languages.remove(4); // Removes "Rust"
        System.out.println("After remove(4): " + languages);
        // Output: After remove(4): [Java, TypeScript, Python, JavaScript, Java]

        // Remove by object (removes first occurrence)
        languages.remove("Java"); // Removes first "Java" at index 0
        System.out.println("After remove(\"Java\"): " + languages);
        // Output: After remove("Java"): [TypeScript, Python, JavaScript, Java]

        // Useful methods
        System.out.println("Size: " + languages.size());         // Output: Size: 4
        System.out.println("Contains Python? " + languages.contains("Python")); // Output: Contains Python? true
        System.out.println("Index of Java: " + languages.indexOf("Java"));      // Output: Index of Java: 3
        System.out.println("Is empty? " + languages.isEmpty());   // Output: Is empty? false

        // Sublist (fromIndex inclusive, toIndex exclusive)
        List<String> subset = languages.subList(1, 3);
        System.out.println("Sublist(1,3): " + subset);
        // Output: Sublist(1,3): [Python, JavaScript]
    }
}

import java.util.LinkedList;
import java.util.Deque;

public class LinkedListExample {
    public static void main(String[] args) {
        // LinkedList as a Deque (double-ended queue)
        Deque<String> taskQueue = new LinkedList<>();

        // Add to front and back
        taskQueue.addFirst("Review PR");
        taskQueue.addLast("Write tests");
        taskQueue.addLast("Deploy to staging");
        taskQueue.addFirst("Fix critical bug"); // Urgent task goes first!
        System.out.println("Task Queue: " + taskQueue);
        // Output: Task Queue: [Fix critical bug, Review PR, Write tests, Deploy to staging]

        // Peek at first and last without removing
        System.out.println("Next task: " + taskQueue.peekFirst());
        // Output: Next task: Fix critical bug
        System.out.println("Last task: " + taskQueue.peekLast());
        // Output: Last task: Deploy to staging

        // Process (remove) from front
        String completed = taskQueue.pollFirst();
        System.out.println("Completed: " + completed);
        // Output: Completed: Fix critical bug
        System.out.println("Remaining: " + taskQueue);
        // Output: Remaining: [Review PR, Write tests, Deploy to staging]

        // Use as a stack (LIFO) -- push/pop operate on the head
        Deque<String> undoStack = new LinkedList<>();
        undoStack.push("Type 'Hello'");
        undoStack.push("Bold text");
        undoStack.push("Change font");
        System.out.println("\nUndo Stack: " + undoStack);
        // Output: Undo Stack: [Change font, Bold text, Type 'Hello']

        String undone = undoStack.pop();
        System.out.println("Undone: " + undone);
        // Output: Undone: Change font
    }
}

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> uniqueEmails = new HashSet<>();

        // Adding elements
        uniqueEmails.add("alice@example.com");
        uniqueEmails.add("bob@example.com");
        uniqueEmails.add("charlie@example.com");

        // Duplicate is rejected
        boolean added = uniqueEmails.add("alice@example.com");
        System.out.println("alice added again? " + added); // Output: alice added again? false
        System.out.println("Size: " + uniqueEmails.size()); // Output: Size: 3

        // Check membership
        System.out.println("Contains bob? " + uniqueEmails.contains("bob@example.com"));
        // Output: Contains bob? true

        // Remove an element
        uniqueEmails.remove("charlie@example.com");
        System.out.println("After remove: " + uniqueEmails);
        // Output: After remove: [bob@example.com, alice@example.com] (order may vary)

        // Iteration -- order is NOT guaranteed
        for (String email : uniqueEmails) {
            System.out.println("Email: " + email);
        }
    }
}

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        Set<String> visitedPages = new LinkedHashSet<>();

        visitedPages.add("/home");
        visitedPages.add("/about");
        visitedPages.add("/products");
        visitedPages.add("/home");     // Duplicate -- ignored
        visitedPages.add("/contact");

        // Iteration preserves insertion order
        System.out.println("Browsing history (unique pages):");
        for (String page : visitedPages) {
            System.out.println("  " + page);
        }
        // Output:
        //   /home
        //   /about
        //   /products
        //   /contact
    }
}

import java.util.TreeSet;
import java.util.NavigableSet;

public class TreeSetExample {
    public static void main(String[] args) {
        NavigableSet<Integer> scores = new TreeSet<>();

        scores.add(85);
        scores.add(92);
        scores.add(78);
        scores.add(95);
        scores.add(88);
        scores.add(85); // Duplicate -- ignored

        // Automatically sorted in natural order (ascending)
        System.out.println("Scores: " + scores);
        // Output: Scores: [78, 85, 88, 92, 95]

        // NavigableSet methods
        System.out.println("First (lowest): " + scores.first());   // Output: First (lowest): 78
        System.out.println("Last (highest): " + scores.last());    // Output: Last (highest): 95
        System.out.println("Lower than 88: " + scores.lower(88));  // Output: Lower than 88: 85
        System.out.println("Higher than 88: " + scores.higher(88));// Output: Higher than 88: 92
        System.out.println("Floor of 90: " + scores.floor(90));    // Output: Floor of 90: 88
        System.out.println("Ceiling of 90: " + scores.ceiling(90));// Output: Ceiling of 90: 92

        // Subset (fromInclusive, toExclusive)
        System.out.println("Scores 80-90: " + scores.subSet(80, true, 90, true));
        // Output: Scores 80-90: [85, 88]

        // Descending order
        System.out.println("Descending: " + scores.descendingSet());
        // Output: Descending: [95, 92, 88, 85, 78]
    }
}

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> wordCount = new HashMap<>();

        // put() -- add or update key-value pairs
        wordCount.put("java", 15);
        wordCount.put("python", 12);
        wordCount.put("javascript", 8);
        wordCount.put("go", 5);
        System.out.println("Word counts: " + wordCount);

        // get() -- retrieve value by key
        int javaCount = wordCount.get("java");
        System.out.println("Java count: " + javaCount); // Output: Java count: 15

        // getOrDefault() -- avoid NullPointerException for missing keys
        int rubyCount = wordCount.getOrDefault("ruby", 0);
        System.out.println("Ruby count: " + rubyCount); // Output: Ruby count: 0

        // put() with existing key -- replaces old value
        wordCount.put("java", 20);
        System.out.println("Java updated: " + wordCount.get("java")); // Output: Java updated: 20

        // putIfAbsent() -- only adds if key is not already present
        wordCount.putIfAbsent("java", 999);    // Ignored -- key exists
        wordCount.putIfAbsent("kotlin", 3);     // Added -- key is new
        System.out.println("Java: " + wordCount.get("java"));     // Output: Java: 20
        System.out.println("Kotlin: " + wordCount.get("kotlin")); // Output: Kotlin: 3

        // Checking keys and values
        System.out.println("Contains 'python' key? " + wordCount.containsKey("python"));   // Output: true
        System.out.println("Contains value 8? " + wordCount.containsValue(8));              // Output: true

        // Size
        System.out.println("Size: " + wordCount.size()); // Output: Size: 5

        // Remove
        wordCount.remove("go");
        System.out.println("After removing 'go': " + wordCount);

        // Iteration -- three ways to iterate a Map
        System.out.println("\n--- keySet() ---");
        for (String key : wordCount.keySet()) {
            System.out.println(key + " -> " + wordCount.get(key));
        }

        System.out.println("\n--- entrySet() (preferred) ---");
        for (Map.Entry<String, Integer> entry : wordCount.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        System.out.println("\n--- values() ---");
        for (int count : wordCount.values()) {
            System.out.println("Count: " + count);
        }

        // Java 8+ forEach with lambda
        System.out.println("\n--- forEach lambda ---");
        wordCount.forEach((key, value) ->
            System.out.println(key + " = " + value)
        );
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // Insertion-order LinkedHashMap
        Map<String, String> config = new LinkedHashMap<>();
        config.put("host", "localhost");
        config.put("port", "8080");
        config.put("protocol", "https");

        // Iteration follows insertion order
        System.out.println("Config (insertion order):");
        config.forEach((key, value) ->
            System.out.println("  " + key + " = " + value)
        );
        // Output:
        //   host = localhost
        //   port = 8080
        //   protocol = https

        // LRU Cache using access-order LinkedHashMap
        // Parameters: initialCapacity, loadFactor, accessOrder
        int maxSize = 3;
        Map<String, String> lruCache = new LinkedHashMap<>(16, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
                return size() > maxSize; // Remove oldest when cache exceeds max size
            }
        };

        lruCache.put("A", "Alpha");
        lruCache.put("B", "Bravo");
        lruCache.put("C", "Charlie");
        System.out.println("\nCache: " + lruCache); // {A=Alpha, B=Bravo, C=Charlie}

        lruCache.get("A"); // Access "A" -- moves it to end
        lruCache.put("D", "Delta"); // Exceeds max size -- evicts least recently used ("B")
        System.out.println("After access A, add D: " + lruCache);
        // Output: After access A, add D: {C=Charlie, A=Alpha, D=Delta}
        // "B" was evicted because it was the least recently used
    }
}

import java.util.TreeMap;
import java.util.NavigableMap;
import java.util.Map;

public class TreeMapExample {
    public static void main(String[] args) {
        NavigableMap<String, Double> studentGrades = new TreeMap<>();

        studentGrades.put("Charlie", 3.5);
        studentGrades.put("Alice", 3.9);
        studentGrades.put("Eve", 3.2);
        studentGrades.put("Bob", 3.7);
        studentGrades.put("Diana", 3.8);

        // Automatically sorted by key (alphabetical for Strings)
        System.out.println("Grades (sorted by name): " + studentGrades);
        // Output: {Alice=3.9, Bob=3.7, Charlie=3.5, Diana=3.8, Eve=3.2}

        // NavigableMap methods
        System.out.println("First: " + studentGrades.firstEntry()); // Alice=3.9
        System.out.println("Last: " + studentGrades.lastEntry());   // Eve=3.2

        // Range query: students from "Bob" to "Diana" (inclusive)
        Map<String, Double> range = studentGrades.subMap("Bob", true, "Diana", true);
        System.out.println("Bob to Diana: " + range);
        // Output: Bob to Diana: {Bob=3.7, Charlie=3.5, Diana=3.8}

        // Floor and ceiling
        System.out.println("Floor of 'D': " + studentGrades.floorKey("D"));     // Charlie
        System.out.println("Ceiling of 'D': " + studentGrades.ceilingKey("D")); // Diana

        // Descending map
        System.out.println("Reverse: " + studentGrades.descendingMap());
        // Output: {Eve=3.2, Diana=3.8, Charlie=3.5, Bob=3.7, Alice=3.9}
    }
}

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Comparator;

public class PriorityQueueExample {
    public static void main(String[] args) {
        // Min-heap (default) -- lowest number = highest priority
        Queue<Integer> minHeap = new PriorityQueue<>();
        minHeap.offer(30);
        minHeap.offer(10);
        minHeap.offer(20);
        minHeap.offer(5);

        System.out.println("Peek (min): " + minHeap.peek()); // Output: 5

        System.out.print("Polling (ascending): ");
        while (!minHeap.isEmpty()) {
            System.out.print(minHeap.poll() + " ");
        }
        // Output: Polling (ascending): 5 10 20 30
        System.out.println();

        // Max-heap using Comparator.reverseOrder()
        Queue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
        maxHeap.offer(30);
        maxHeap.offer(10);
        maxHeap.offer(20);
        maxHeap.offer(5);

        System.out.print("Polling (descending): ");
        while (!maxHeap.isEmpty()) {
            System.out.print(maxHeap.poll() + " ");
        }
        // Output: Polling (descending): 30 20 10 5
        System.out.println();

        // Priority queue with custom objects
        record Task(String name, int priority) {}

        Queue<Task> taskQueue = new PriorityQueue<>(
            Comparator.comparingInt(Task::priority) // Lower number = higher priority
        );

        taskQueue.offer(new Task("Send email", 3));
        taskQueue.offer(new Task("Fix production bug", 1));
        taskQueue.offer(new Task("Update docs", 5));
        taskQueue.offer(new Task("Code review", 2));

        System.out.println("\nProcessing tasks by priority:");
        while (!taskQueue.isEmpty()) {
            Task task = taskQueue.poll();
            System.out.println("  [P" + task.priority() + "] " + task.name());
        }
        // Output:
        //   [P1] Fix production bug
        //   [P2] Code review
        //   [P3] Send email
        //   [P5] Update docs
    }
}

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        // Use as a STACK (LIFO) -- push/pop at the head
        Deque<String> callStack = new ArrayDeque<>();
        callStack.push("main()");
        callStack.push("processOrder()");
        callStack.push("validatePayment()");
        callStack.push("chargeCard()");

        System.out.println("Call stack: " + callStack);
        // Output: [chargeCard(), validatePayment(), processOrder(), main()]

        System.out.println("Current: " + callStack.peek()); // chargeCard()
        callStack.pop(); // chargeCard() returns
        System.out.println("After pop: " + callStack.peek()); // validatePayment()

        // Use as a QUEUE (FIFO) -- offer at tail, poll from head
        Deque<String> printQueue = new ArrayDeque<>();
        printQueue.offer("Document1.pdf");
        printQueue.offer("Photo.jpg");
        printQueue.offer("Report.xlsx");

        System.out.println("\nPrint queue: " + printQueue);
        System.out.println("Printing: " + printQueue.poll()); // Document1.pdf
        System.out.println("Printing: " + printQueue.poll()); // Photo.jpg
        System.out.println("Remaining: " + printQueue);       // [Report.xlsx]
    }
}

List<String> names = List.of("Alice", "Bob", "Charlie");

// For-each loop -- clean and simple
for (String name : names) {
    System.out.println(name);
}
// Output:
// Alice
// Bob
// Charlie

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

public class IteratorExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7, 8));

        // Remove all even numbers using Iterator
        Iterator<Integer> it = numbers.iterator();
        while (it.hasNext()) {
            int num = it.next();
            if (num % 2 == 0) {
                it.remove(); // Safe removal during iteration
            }
        }
        System.out.println("Odd numbers: " + numbers);
        // Output: Odd numbers: [1, 3, 5, 7]
    }
}

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

public class ListIteratorExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("apple", "banana", "cherry"));

        ListIterator<String> lit = items.listIterator();
        while (lit.hasNext()) {
            int index = lit.nextIndex();
            String item = lit.next();
            lit.set(item.toUpperCase()); // Replace current element
            System.out.println("[" + index + "] " + item + " -> " + item.toUpperCase());
        }
        // Output:
        // [0] apple -> APPLE
        // [1] banana -> BANANA
        // [2] cherry -> CHERRY

        System.out.println("Updated list: " + items);
        // Output: Updated list: [APPLE, BANANA, CHERRY]

        // Traverse backwards
        System.out.print("Reverse: ");
        while (lit.hasPrevious()) {
            System.out.print(lit.previous() + " ");
        }
        // Output: Reverse: CHERRY BANANA APPLE
    }
}

import java.util.List;
import java.util.Map;

public class ForEachLambdaExample {
    public static void main(String[] args) {
        // Collection.forEach()
        List<String> fruits = List.of("Apple", "Banana", "Cherry");
        fruits.forEach(fruit -> System.out.println("Fruit: " + fruit));

        // Map.forEach() -- provides both key and value
        Map<String, Integer> inventory = Map.of("Apple", 50, "Banana", 30, "Cherry", 20);
        inventory.forEach((item, qty) ->
            System.out.println(item + ": " + qty + " in stock")
        );

        // Method reference -- even more concise
        fruits.forEach(System.out::println);

        // stream().forEach() -- use when chaining stream operations
        fruits.stream()
              .filter(f -> f.startsWith("B"))
              .forEach(f -> System.out.println("Starts with B: " + f));
        // Output: Starts with B: Banana
    }
}

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

public class ConcurrentModificationExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Alice", "Bob", "Charlie", "David"));

        // BAD -- throws ConcurrentModificationException
        // for (String name : names) {
        //     if (name.startsWith("C")) {
        //         names.remove(name); // Modifying collection during for-each!
        //     }
        // }

        // SOLUTION 1: Use Iterator.remove()
        var it = names.iterator();
        while (it.hasNext()) {
            if (it.next().startsWith("C")) {
                it.remove();
            }
        }
        System.out.println("After iterator remove: " + names);
        // Output: After iterator remove: [Alice, Bob, David]

        // SOLUTION 2: Use removeIf() (Java 8+) -- cleanest approach
        List<String> names2 = new ArrayList<>(List.of("Alice", "Bob", "Charlie", "David"));
        names2.removeIf(name -> name.startsWith("C"));
        System.out.println("After removeIf: " + names2);
        // Output: After removeIf: [Alice, Bob, David]

        // SOLUTION 3: Collect items to remove, then removeAll
        List<String> names3 = new ArrayList<>(List.of("Alice", "Bob", "Charlie", "David"));
        List<String> toRemove = new ArrayList<>();
        for (String name : names3) {
            if (name.startsWith("C")) {
                toRemove.add(name);
            }
        }
        names3.removeAll(toRemove);
        System.out.println("After removeAll: " + names3);
        // Output: After removeAll: [Alice, Bob, David]
    }
}

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

// Employee implements Comparable -- natural ordering by salary
public class Employee implements Comparable<Employee> {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() { return name; }
    public double getSalary() { return salary; }

    @Override
    public int compareTo(Employee other) {
        // Natural ordering: by salary ascending
        return Double.compare(this.salary, other.salary);
    }

    @Override
    public String toString() {
        return name + " ($" + String.format("%.0f", salary) + ")";
    }

    public static void main(String[] args) {
        List<Employee> team = new ArrayList<>();
        team.add(new Employee("Alice", 85000));
        team.add(new Employee("Bob", 72000));
        team.add(new Employee("Charlie", 95000));
        team.add(new Employee("Diana", 78000));

        // Sort using natural ordering (compareTo)
        Collections.sort(team);
        System.out.println("By salary (natural): " + team);
        // Output: By salary (natural): [Bob ($72000), Diana ($78000), Alice ($85000), Charlie ($95000)]

        // Or use List.sort() -- same result
        team.sort(null); // null means use natural ordering
    }
}

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

public class ComparatorExample {
    record Employee(String name, String department, double salary) {}

    public static void main(String[] args) {
        List<Employee> team = new ArrayList<>();
        team.add(new Employee("Alice", "Engineering", 85000));
        team.add(new Employee("Bob", "Marketing", 72000));
        team.add(new Employee("Charlie", "Engineering", 95000));
        team.add(new Employee("Diana", "Marketing", 78000));
        team.add(new Employee("Eve", "Engineering", 85000));

        // Sort by name (alphabetical)
        team.sort(Comparator.comparing(Employee::name));
        System.out.println("By name:");
        team.forEach(e -> System.out.println("  " + e));
        // Alice, Bob, Charlie, Diana, Eve

        // Sort by salary descending
        team.sort(Comparator.comparingDouble(Employee::salary).reversed());
        System.out.println("\nBy salary (descending):");
        team.forEach(e -> System.out.println("  " + e));
        // Charlie (95000), Alice (85000), Eve (85000), Diana (78000), Bob (72000)

        // Sort by department, then by salary descending within department
        team.sort(Comparator.comparing(Employee::department)
                            .thenComparing(Comparator.comparingDouble(Employee::salary).reversed()));
        System.out.println("\nBy department, then salary desc:");
        team.forEach(e -> System.out.println("  " + e));
        // Output:
        //   Employee[name=Charlie, department=Engineering, salary=95000.0]
        //   Employee[name=Alice, department=Engineering, salary=85000.0]
        //   Employee[name=Eve, department=Engineering, salary=85000.0]
        //   Employee[name=Diana, department=Marketing, salary=78000.0]
        //   Employee[name=Bob, department=Marketing, salary=72000.0]

        // Handling nulls
        List<String> items = new ArrayList<>(List.of("Banana", "Apple"));
        items.add(null);
        items.add("Cherry");

        items.sort(Comparator.nullsLast(Comparator.naturalOrder()));
        System.out.println("\nWith nulls last: " + items);
        // Output: With nulls last: [Apple, Banana, Cherry, null]
    }
}

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

public class CollectionsUtilityExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(5, 3, 8, 1, 9, 2, 7));

        // --- Sorting ---
        Collections.sort(numbers);
        System.out.println("Sorted: " + numbers);
        // Output: Sorted: [1, 2, 3, 5, 7, 8, 9]

        // --- Reverse ---
        Collections.reverse(numbers);
        System.out.println("Reversed: " + numbers);
        // Output: Reversed: [9, 8, 7, 5, 3, 2, 1]

        // --- Shuffle (random order) ---
        Collections.shuffle(numbers);
        System.out.println("Shuffled: " + numbers);
        // Output: Shuffled: [3, 5, 1, 9, 7, 2, 8] (random each time)

        // --- Min and Max ---
        Collections.sort(numbers); // Re-sort for clarity
        System.out.println("Min: " + Collections.min(numbers)); // Output: Min: 1
        System.out.println("Max: " + Collections.max(numbers)); // Output: Max: 9

        // --- Frequency ---
        List<String> words = List.of("java", "python", "java", "go", "java", "python");
        System.out.println("'java' appears: " + Collections.frequency(words, "java") + " times");
        // Output: 'java' appears: 3 times

        // --- Binary Search (list must be sorted!) ---
        List<Integer> sorted = List.of(10, 20, 30, 40, 50);
        int index = Collections.binarySearch(sorted, 30);
        System.out.println("Index of 30: " + index); // Output: Index of 30: 2

        // --- Unmodifiable List (read-only wrapper) ---
        List<String> mutable = new ArrayList<>(List.of("A", "B", "C"));
        List<String> readOnly = Collections.unmodifiableList(mutable);
        // readOnly.add("D"); // Throws UnsupportedOperationException!
        System.out.println("Read-only: " + readOnly);

        // --- Empty collections (immutable) ---
        List<String> empty = Collections.emptyList();
        System.out.println("Empty list: " + empty); // Output: Empty list: []
        // empty.add("X"); // Throws UnsupportedOperationException!

        // --- Singleton (immutable single-element collection) ---
        List<String> single = Collections.singletonList("OnlyOne");
        System.out.println("Singleton: " + single); // Output: Singleton: [OnlyOne]

        // --- Fill ---
        List<String> template = new ArrayList<>(List.of("A", "B", "C", "D"));
        Collections.fill(template, "X");
        System.out.println("Filled: " + template); // Output: Filled: [X, X, X, X]

        // --- Swap ---
        List<String> letters = new ArrayList<>(List.of("A", "B", "C"));
        Collections.swap(letters, 0, 2);
        System.out.println("Swapped: " + letters); // Output: Swapped: [C, B, A]

        // --- nCopies (immutable) ---
        List<String> copies = Collections.nCopies(5, "Hello");
        System.out.println("Copies: " + copies); // Output: Copies: [Hello, Hello, Hello, Hello, Hello]
    }
}

import java.util.List;
import java.util.Set;
import java.util.Map;

public class ImmutableFactoryExample {
    public static void main(String[] args) {
        // List.of() -- immutable list
        List<String> colors = List.of("Red", "Green", "Blue");
        System.out.println("Colors: " + colors);
        // colors.add("Yellow"); // UnsupportedOperationException!

        // Set.of() -- immutable set (no duplicates allowed)
        Set<Integer> primes = Set.of(2, 3, 5, 7, 11);
        System.out.println("Primes: " + primes);

        // Map.of() -- immutable map (up to 10 entries)
        Map<String, Integer> scores = Map.of(
            "Alice", 95,
            "Bob", 87,
            "Charlie", 92
        );
        System.out.println("Scores: " + scores);

        // Map.ofEntries() -- immutable map (any number of entries)
        Map<String, String> config = Map.ofEntries(
            Map.entry("host", "localhost"),
            Map.entry("port", "8080"),
            Map.entry("env", "production"),
            Map.entry("debug", "false")
        );
        System.out.println("Config: " + config);

        // To create a mutable copy from an immutable collection:
        List<String> mutableColors = new java.util.ArrayList<>(colors);
        mutableColors.add("Yellow"); // This works!
        System.out.println("Mutable colors: " + mutableColors);
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.List;
import java.util.Map;

public class ThreadSafeCollectionsExample {
    public static void main(String[] args) {
        // ConcurrentHashMap -- the go-to thread-safe map
        Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("counter", 0);

        // Safe atomic operations
        concurrentMap.compute("counter", (key, value) -> value + 1);
        concurrentMap.merge("counter", 1, Integer::sum);
        System.out.println("Counter: " + concurrentMap.get("counter")); // Output: Counter: 2

        // putIfAbsent -- atomic check-and-put
        concurrentMap.putIfAbsent("newKey", 100);
        System.out.println("New key: " + concurrentMap.get("newKey")); // Output: New key: 100

        // CopyOnWriteArrayList -- great for listener/observer patterns
        List<String> listeners = new CopyOnWriteArrayList<>();
        listeners.add("LoggingListener");
        listeners.add("MetricsListener");
        listeners.add("AlertListener");

        // Safe to iterate even if another thread modifies the list
        // (iterates over a snapshot)
        for (String listener : listeners) {
            System.out.println("Notifying: " + listener);
        }
    }
}

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class HashCodeMistake {

    // BAD -- overrides equals() but NOT hashCode()
    static class BadProduct {
        String name;
        BadProduct(String name) { this.name = name; }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof BadProduct)) return false;
            return name.equals(((BadProduct) o).name);
        }
        // Missing hashCode()!
    }

    // GOOD -- overrides both equals() AND hashCode()
    static class GoodProduct {
        String name;
        GoodProduct(String name) { this.name = name; }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof GoodProduct)) return false;
            return name.equals(((GoodProduct) o).name);
        }

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

    public static void main(String[] args) {
        // BAD: Two equal objects, different hash codes -> set treats them as different
        Set<BadProduct> badSet = new HashSet<>();
        badSet.add(new BadProduct("Laptop"));
        badSet.add(new BadProduct("Laptop")); // Should be duplicate!
        System.out.println("Bad set size: " + badSet.size());
        // Output: Bad set size: 2 (BUG! Should be 1)

        // GOOD: Two equal objects, same hash code -> set correctly rejects duplicate
        Set<GoodProduct> goodSet = new HashSet<>();
        goodSet.add(new GoodProduct("Laptop"));
        goodSet.add(new GoodProduct("Laptop"));
        System.out.println("Good set size: " + goodSet.size());
        // Output: Good set size: 1 (Correct!)
    }
}

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

public class AutoboxingPitfall {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(10, 20, 30, 40, 50));

        // This removes the element at INDEX 2 (which is 30), NOT the value 2!
        numbers.remove(2);
        System.out.println("After remove(2): " + numbers);
        // Output: After remove(2): [10, 20, 40, 50]

        // To remove the VALUE 20, you must box it explicitly:
        numbers.remove(Integer.valueOf(20));
        System.out.println("After remove(Integer.valueOf(20)): " + numbers);
        // Output: After remove(Integer.valueOf(20)): [10, 40, 50]
    }
}

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

public class RawTypeMistake {
    public static void main(String[] args) {
        // BAD -- raw type (no generics). Compiles but dangerous!
        List rawList = new ArrayList();
        rawList.add("Hello");
        rawList.add(42);       // No compile error -- anything goes
        rawList.add(true);     // No compile error
        // String s = (String) rawList.get(1); // ClassCastException at runtime!

        // GOOD -- parameterized type. Type safety at compile time.
        List<String> typedList = new ArrayList<>();
        typedList.add("Hello");
        // typedList.add(42);  // Compile error! Cannot add Integer to List<String>
        String s = typedList.get(0); // No cast needed -- compiler knows it's a String
        System.out.println(s);
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class MutableKeyMistake {
    static class MutableKey {
        String value;
        MutableKey(String value) { this.value = value; }

        @Override
        public int hashCode() { return Objects.hash(value); }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof MutableKey)) return false;
            return value.equals(((MutableKey) o).value);
        }
    }

    public static void main(String[] args) {
        Map<MutableKey, String> map = new HashMap<>();
        MutableKey key = new MutableKey("original");
        map.put(key, "some data");

        System.out.println("Before mutation: " + map.get(key)); // Output: some data

        // Mutate the key -- hash code changes!
        key.value = "mutated";
        System.out.println("After mutation: " + map.get(key));  // Output: null (LOST!)
        System.out.println("Map size: " + map.size());          // Output: Map size: 1 (entry exists but unreachable)

        // Lesson: Always use immutable objects as Map keys (String, Integer, record, etc.)
    }
}

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

public class ImmutableMistake {
    public static void main(String[] args) {
        // List.of() returns an IMMUTABLE list
        List<String> immutable = List.of("A", "B", "C");

        try {
            immutable.add("D"); // UnsupportedOperationException!
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot modify List.of() -- it's immutable!");
        }

        // If you need to modify it, create a mutable copy first
        List<String> mutable = new ArrayList<>(immutable);
        mutable.add("D"); // This works
        System.out.println("Mutable copy: " + mutable);
        // Output: Mutable copy: [A, B, C, D]
    }
}

// BAD -- coupled to the implementation
ArrayList<String> names = new ArrayList<>();
HashMap<String, Integer> scores = new HashMap<>();

// GOOD -- programmed to the interface
List<String> names = new ArrayList<>();    // Can easily swap to LinkedList
Map<String, Integer> scores = new HashMap<>(); // Can easily swap to TreeMap
Set<String> tags = new HashSet<>();        // Can easily swap to LinkedHashSet

// BAD -- redundant type specification (pre-Java 7 style)
Map<String, List<Integer>> map = new HashMap<String, List<Integer>>();

// GOOD -- diamond operator infers the type
Map<String, List<Integer>> map = new HashMap<>();

List<String> items = new ArrayList<>();

// BAD -- size() might be O(n) for some implementations
if (items.size() == 0) { /* ... */ }

// GOOD -- isEmpty() is always O(1) and more readable
if (items.isEmpty()) { /* ... */ }

// BAD -- default capacity (10), will resize multiple times for 1000 elements
List<String> names = new ArrayList<>();

// GOOD -- pre-sized to avoid resizing
List<String> names = new ArrayList<>(1000);

// For HashMap, account for load factor (default 0.75)
// To hold 100 entries without resize: 100 / 0.75 = 134
Map<String, String> cache = new HashMap<>(134);

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

public class ReturnEmptyExample {

    // BAD -- forces callers to null-check
    public static List<String> getNamesBad(boolean hasData) {
        if (!hasData) {
            return null; // Caller: if (result != null) { ... }
        }
        return List.of("Alice", "Bob");
    }

    // GOOD -- callers can always iterate safely
    public static List<String> getNamesGood(boolean hasData) {
        if (!hasData) {
            return Collections.emptyList(); // Or List.of()
        }
        return List.of("Alice", "Bob");
    }

    public static void main(String[] args) {
        // No null check needed -- this is always safe
        for (String name : getNamesGood(false)) {
            System.out.println(name); // Simply doesn't execute
        }
    }
}

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

public class StreamVsLoopExample {
    public static void main(String[] args) {
        List<String> names = List.of("alice", "bob", "charlie", "diana");

        // GOOD -- Stream for transformation (creating a new collection)
        List<String> uppercased = names.stream()
            .filter(name -> name.length() > 3)
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        System.out.println("Filtered + uppercased: " + uppercased);
        // Output: Filtered + uppercased: [ALICE, CHARLIE, DIANA]

        // GOOD -- Loop for side effects (printing, saving to DB, etc.)
        for (String name : uppercased) {
            System.out.println("Processing: " + name);
        }
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class ContactManager {

    // --- Contact Record ---
    static class Contact implements Comparable<Contact> {
        private final String name;
        private final String email;
        private final String phone;
        private final Set<String> tags; // TreeSet for sorted tags

        public Contact(String name, String email, String phone, String... tags) {
            this.name = name;
            this.email = email;
            this.phone = phone;
            this.tags = new TreeSet<>(Arrays.asList(tags));
        }

        public String getName() { return name; }
        public String getEmail() { return email; }
        public String getPhone() { return phone; }
        public Set<String> getTags() { return Collections.unmodifiableSet(tags); }

        public void addTag(String tag) { tags.add(tag); }
        public void removeTag(String tag) { tags.remove(tag); }

        @Override
        public int compareTo(Contact other) {
            return this.name.compareToIgnoreCase(other.name); // Natural ordering by name
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Contact)) return false;
            return email.equalsIgnoreCase(((Contact) o).email); // Email is unique identifier
        }

        @Override
        public int hashCode() {
            return Objects.hash(email.toLowerCase());
        }

        @Override
        public String toString() {
            return String.format("%-15s %-25s %-15s %s", name, email, phone, tags);
        }
    }

    // --- Contact Manager ---
    private final List<Contact> contacts;          // Ordered list of all contacts
    private final Map<String, Contact> emailIndex; // Fast lookup by email
    private final Set<String> allTags;             // All unique tags across contacts

    public ContactManager() {
        this.contacts = new ArrayList<>();
        this.emailIndex = new HashMap<>();
        this.allTags = new TreeSet<>();
    }

    // Add a contact
    public boolean addContact(Contact contact) {
        if (emailIndex.containsKey(contact.getEmail().toLowerCase())) {
            System.out.println("  Contact with email " + contact.getEmail() + " already exists.");
            return false;
        }
        contacts.add(contact);
        emailIndex.put(contact.getEmail().toLowerCase(), contact);
        allTags.addAll(contact.getTags());
        return true;
    }

    // Find by email -- O(1) using HashMap
    public Contact findByEmail(String email) {
        return emailIndex.get(email.toLowerCase());
    }

    // Find by tag -- filter contacts that have a specific tag
    public List<Contact> findByTag(String tag) {
        return contacts.stream()
            .filter(c -> c.getTags().contains(tag))
            .collect(Collectors.toList());
    }

    // Remove a contact
    public boolean removeContact(String email) {
        Contact contact = emailIndex.remove(email.toLowerCase());
        if (contact != null) {
            contacts.remove(contact);
            rebuildTagIndex();
            return true;
        }
        return false;
    }

    // Get all contacts sorted by name
    public List<Contact> getContactsSortedByName() {
        List<Contact> sorted = new ArrayList<>(contacts);
        Collections.sort(sorted); // Uses Comparable (by name)
        return sorted;
    }

    // Get all contacts sorted by custom criteria
    public List<Contact> getContactsSorted(Comparator<Contact> comparator) {
        List<Contact> sorted = new ArrayList<>(contacts);
        sorted.sort(comparator);
        return sorted;
    }

    // Get all unique tags
    public Set<String> getAllTags() {
        return Collections.unmodifiableSet(allTags);
    }

    // Get contact count per tag
    public Map<String, Long> getTagCounts() {
        return contacts.stream()
            .flatMap(c -> c.getTags().stream())
            .collect(Collectors.groupingBy(tag -> tag, TreeMap::new, Collectors.counting()));
    }

    // Rebuild tag index after removal
    private void rebuildTagIndex() {
        allTags.clear();
        contacts.forEach(c -> allTags.addAll(c.getTags()));
    }

    public int size() { return contacts.size(); }

    // --- Print all contacts ---
    public void printAll() {
        System.out.printf("%-15s %-25s %-15s %s%n", "NAME", "EMAIL", "PHONE", "TAGS");
        System.out.println("-".repeat(75));
        for (Contact c : contacts) {
            System.out.println(c);
        }
    }

    // --- Main: Demonstration ---
    public static void main(String[] args) {
        ContactManager manager = new ContactManager();

        // 1. ADD CONTACTS
        System.out.println("=== Adding Contacts ===");
        manager.addContact(new Contact("Alice Smith",   "alice@example.com",   "555-0101", "friend", "work"));
        manager.addContact(new Contact("Bob Johnson",   "bob@example.com",     "555-0102", "work", "engineering"));
        manager.addContact(new Contact("Charlie Brown", "charlie@example.com", "555-0103", "friend", "school"));
        manager.addContact(new Contact("Diana Prince",  "diana@example.com",   "555-0104", "work", "engineering", "lead"));
        manager.addContact(new Contact("Eve Davis",     "eve@example.com",     "555-0105", "friend"));
        manager.addContact(new Contact("Alice Smith",   "alice@example.com",   "555-9999", "duplicate"));
        // Output: Contact with email alice@example.com already exists.

        System.out.println("\nTotal contacts: " + manager.size());
        // Output: Total contacts: 5

        // 2. DISPLAY ALL CONTACTS
        System.out.println("\n=== All Contacts ===");
        manager.printAll();

        // 3. FAST LOOKUP BY EMAIL (HashMap -- O(1))
        System.out.println("\n=== Lookup by Email ===");
        Contact found = manager.findByEmail("diana@example.com");
        System.out.println("Found: " + found);

        Contact notFound = manager.findByEmail("nobody@example.com");
        System.out.println("Not found: " + notFound); // Output: Not found: null

        // 4. SEARCH BY TAG
        System.out.println("\n=== Contacts Tagged 'engineering' ===");
        List<Contact> engineers = manager.findByTag("engineering");
        engineers.forEach(c -> System.out.println("  " + c.getName() + " - " + c.getEmail()));
        // Output:
        //   Bob Johnson - bob@example.com
        //   Diana Prince - diana@example.com

        // 5. ALL UNIQUE TAGS (TreeSet -- sorted)
        System.out.println("\n=== All Tags (sorted) ===");
        System.out.println(manager.getAllTags());
        // Output: [engineering, friend, lead, school, work]

        // 6. TAG FREQUENCY (TreeMap -- sorted by tag name)
        System.out.println("\n=== Tag Counts ===");
        manager.getTagCounts().forEach((tag, count) ->
            System.out.println("  " + tag + ": " + count)
        );
        // Output:
        //   engineering: 2
        //   friend: 3
        //   lead: 1
        //   school: 1
        //   work: 3

        // 7. SORTING -- by name (natural ordering via Comparable)
        System.out.println("\n=== Sorted by Name ===");
        manager.getContactsSortedByName().forEach(c ->
            System.out.println("  " + c.getName())
        );
        // Output: Alice Smith, Bob Johnson, Charlie Brown, Diana Prince, Eve Davis

        // 8. SORTING -- by email (custom Comparator)
        System.out.println("\n=== Sorted by Email ===");
        manager.getContactsSorted(Comparator.comparing(Contact::getEmail)).forEach(c ->
            System.out.println("  " + c.getEmail())
        );

        // 9. SORTING -- by number of tags (descending), then by name
        System.out.println("\n=== Sorted by Tag Count (desc), then Name ===");
        manager.getContactsSorted(
            Comparator.comparingInt((Contact c) -> c.getTags().size())
                      .reversed()
                      .thenComparing(Contact::getName, String.CASE_INSENSITIVE_ORDER)
        ).forEach(c ->
            System.out.println("  " + c.getName() + " (" + c.getTags().size() + " tags) " + c.getTags())
        );
        // Diana Prince (3 tags), Alice Smith (2 tags), Bob Johnson (2 tags), ...

        // 10. REMOVE A CONTACT
        System.out.println("\n=== Removing Charlie ===");
        boolean removed = manager.removeContact("charlie@example.com");
        System.out.println("Removed: " + removed); // Output: Removed: true
        System.out.println("Total after removal: " + manager.size()); // Output: 4
        System.out.println("Tags after removal: " + manager.getAllTags());
        // "school" tag is gone because Charlie was the only one with it

        // 11. ITERATING WITH INDEX (traditional for loop)
        System.out.println("\n=== Final Contact List with Index ===");
        List<Contact> sorted = manager.getContactsSortedByName();
        for (int i = 0; i < sorted.size(); i++) {
            System.out.println("  " + (i + 1) + ". " + sorted.get(i).getName());
        }
        // Output:
        //   1. Alice Smith
        //   2. Bob Johnson
        //   3. Diana Prince
        //   4. Eve Davis
    }
}