Collections Interview Questions

Iterable
  └── Collection
        ├── List   → ArrayList, LinkedList, Vector
        ├── Set    → HashSet, LinkedHashSet, TreeSet (SortedSet)
        └── Queue  → PriorityQueue, Deque → ArrayDeque, LinkedList

Map (separate hierarchy) → HashMap, LinkedHashMap, TreeMap, Hashtable, ConcurrentHashMap

1. HashMap keeps an array of buckets (default capacity 16, load factor 0.75).
2. put(k, v) computes k.hashCode(), spreads the bits, and picks bucket (n - 1) & hash.
3. If the bucket has entries (a collision), it walks them using equals(): same key → replace value, else append.
4. Since Java 8, a bucket with more than 8 entries (and table ≥ 64) becomes a red-black tree, so worst case is O(log n) instead of O(n).
5. When size exceeds capacity × load factor, the table doubles and entries are redistributed (rehashing).

• If a.equals(b) is true, then a.hashCode() == b.hashCode() must be true.
• Equal hash codes do not imply equal objects (collisions are allowed).
• If you override equals(), always override hashCode(); otherwise HashMap/HashSet will not find your objects.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Set<BadEmp> bad = new HashSet<>();
        bad.add(new BadEmp(1));
        bad.add(new BadEmp(1));
        System.out.println("Without hashCode: " + bad.size());

        Set<GoodEmp> good = new HashSet<>();
        good.add(new GoodEmp(1));
        good.add(new GoodEmp(1));
        System.out.println("With hashCode:    " + good.size());
    }
}

class BadEmp {
    int id;
    BadEmp(int id) { this.id = id; }
    @Override public boolean equals(Object o) { return o instanceof BadEmp e && e.id == id; }
}

class GoodEmp {
    int id;
    GoodEmp(int id) { this.id = id; }
    @Override public boolean equals(Object o) { return o instanceof GoodEmp e && e.id == id; }
    @Override public int hashCode() { return Objects.hash(id); }
}

Without hashCode: 2
With hashCode:    1

A fail-fast iterator (ArrayList, HashMap) throws ConcurrentModificationException if the collection is structurally modified during iteration (it checks a modCount). A fail-safe / weakly consistent iterator (CopyOnWriteArrayList, ConcurrentHashMap) works on a snapshot or tolerates changes and never throws.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        try {
            for (Integer n : nums) {
                if (n % 2 == 0) nums.remove(n);
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Caught: " + e.getClass().getSimpleName());
        }
        nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);
        System.out.println("After removeIf: " + nums);
    }
}

Caught: ConcurrentModificationException
After removeIf: [1, 3, 5]