Collections Framework

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

Set<String> uniqueNames = new HashSet<>(names);  // duplicates automatically removed

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);

Common follow-ups: Why doesn't Map extend the Collection interface despite being part of the Collections Framework?;How do you choose between List, Set, and Map for a given problem?

List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();

// O(1) for ArrayList, O(n) for LinkedList
arrayList.get(500);

// O(n) for ArrayList (shifts elements), O(1) for LinkedList IF you already have the position via iterator
arrayList.add(0, value);  // insert at front, expensive for ArrayList

Common follow-ups: Why does LinkedList's theoretical O(1) insertion advantage rarely materialize in practice for common use patterns?;What's the actual per-element memory overhead difference between ArrayList and LinkedList?

// Conceptual illustration of what happens internally with many colliding keys
Map<CustomKey, String> map = new HashMap<>();
// If many CustomKey instances have colliding/identical hashCode() values,
// their bucket's internal linked list can grow long --
// Java 8+ automatically converts it to a red-black tree once it exceeds 8 entries
// (assuming the table has at least 64 buckets), bounding worst-case lookup to O(log n)

Common follow-ups: What must a key class satisfy (Comparable) for treeification to actually be usable, and what happens if it doesn't?;How does HashMap's load factor and resizing (rehashing) interact with this bucket structure?

public class Point {
    private final int x, y;
    // constructor omitted

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Point p)) return false;
        return x == p.x && y == p.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);  // MUST be consistent with equals()
    }
}

Common follow-ups: What happens if hashCode() is overridden but equals() is not, in terms of contract violation risk?;Why does Object's default hashCode() implementation (based on memory address) become invalid once equals() is overridden?

// LinkedHashMap configured for LRU eviction behavior
Map<String, String> lruCache = new LinkedHashMap<>(16, 0.75f, true) {
    @Override
    protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
        return size() > 100;  // evict oldest-accessed entry once capacity exceeded
    }
};

// TreeMap for sorted iteration and range queries
TreeMap<Integer, String> sortedMap = new TreeMap<>();
sortedMap.put(3, "c"); sortedMap.put(1, "a"); sortedMap.put(2, "b");
System.out.println(sortedMap.firstKey());  // 1, always sorted
System.out.println(sortedMap.headMap(3));  // entries with keys < 3

Common follow-ups: What's the performance cost of LinkedHashMap's extra linked-list maintenance compared to plain HashMap?;How does TreeMap's red-black tree implementation guarantee O(log n) worst-case (unlike HashMap's amortized-but-not-guaranteed O(1))?

List<String> list = new ArrayList<>(List.of("a", "b", "c"));
for (String s : list) {
    if (s.equals("b")) {
        list.remove(s);  // throws ConcurrentModificationException! Fail-fast detects the structural change
    }
}

// Correct approach: use an Iterator's own remove() method
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("b")) it.remove();  // safe, iterator-aware removal
}

Common follow-ups: Why does fail-fast detection use "best-effort" language rather than being a strict guarantee?;What's the memory/performance trade-off of CopyOnWriteArrayList's fail-safe snapshot approach?

public class Employee implements Comparable<Employee> {
    private final int salary;
    // constructor omitted

    @Override
    public int compareTo(Employee other) {
        return Integer.compare(this.salary, other.salary);
        // NOTE: TreeSet<Employee> would consider two employees with EQUAL salary as
        // "duplicates" (compareTo == 0), even if their equals()/other fields genuinely differ!
    }
}

Common follow-ups: Why is it recommended that a class's compareTo() be "consistent with equals" even though it's not strictly enforced by the compiler?;What specific tree rotation operations restore red-black balance after an insertion that violates the coloring invariants?

List<String> immutable = List.of("a", "b", "c");  // genuinely immutable, rejects null
// immutable.add("d");  // throws UnsupportedOperationException

List<String> mutableBacking = new ArrayList<>(List.of("a", "b"));
List<String> view = Collections.unmodifiableList(mutableBacking);
mutableBacking.add("c");  // view now reflects this change too! The "unmodifiable" view isn't truly immutable data

Common follow-ups: Why do List.of() and friends reject null elements while ArrayList happily allows them?;What's the performance/memory characteristic difference between List.of()'s immutable implementation and a regular ArrayList?

List<Employee> employees = ...;
employees.sort(
    Comparator.comparing(Employee::getLastName)
              .thenComparing(Employee::getFirstName)
              .thenComparing(Employee::getSalary, Comparator.reverseOrder())
);
// Sorts by last name, ties broken by first name, further ties broken by salary descending

Common follow-ups: How does thenComparing() know when the previous comparator considered two elements 'equal' (compare() returned 0)?;What's the performance implication of a multi-field Comparator chain compared to a single hand-optimized compare() method?

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1); stack.push(2); stack.push(3);
System.out.println(stack.pop());  // 3, LIFO stack behavior

Deque<Integer> queue = new ArrayDeque<>();
queue.offer(1); queue.offer(2); queue.offer(3);
System.out.println(queue.poll());  // 1, FIFO queue behavior

Common follow-ups: Why is java.util.Stack considered a design mistake in the JDK despite still being available and functional?;What's the performance difference between ArrayDeque and LinkedList when both are used as a Deque?