HashMap

// ── HashMap internal structure (Java 8+): ────────────────────────────
// HashMap<K,V> {
//   Node<K,V>[] table;      // the bucket array
//   int size;               // number of key-value mappings
//   int threshold;          // size * loadFactor — resize when exceeded
//   float loadFactor;       // default 0.75
// }
//
// Node<K,V> {
//   int hash;
//   K key;
//   V value;
//   Node<K,V> next;         // linked list chain or tree node
// }
//
// put("Alice", 90):
//   hash = "Alice".hashCode()  (= some int, e.g. 63557208)
//   spread = hash ^ (hash >>> 16)
//   bucket = spread & (capacity-1)  e.g. spread & 15 = bucket 8
//   table[8] = new Node(hash, "Alice", 90, null)

// ── Creating HashMap: ────────────────────────────────────────────────
Map<String, Integer> map = new HashMap<>();
Map<String, Integer> withCapacity = new HashMap<>(32);        // initial capacity
Map<String, Integer> withBoth     = new HashMap<>(32, 0.5f);  // capacity + load factor
Map<String, Integer> fromMap      = new HashMap<>(existingMap);

// ── Basic operations: ─────────────────────────────────────────────────
map.put("Alice", 90);
map.put("Bob",   85);
map.put("Carol", 92);
map.put("Alice", 95);    // replaces existing — returns old value 90

Integer score  = map.get("Alice");        // 95
Integer absent = map.get("Dave");         // null — key not present
boolean hasBob = map.containsKey("Bob");  // true
boolean has85  = map.containsValue(85);   // true
int     size   = map.size();              // 3
map.remove("Carol");                      // removes entry
Integer old    = map.remove("Bob", 85);   // conditional remove — only if value matches

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob",   85);

// ── Safe retrieval: ───────────────────────────────────────────────────
System.out.println(scores.getOrDefault("Carol", 0));   // 0 — not in map
System.out.println(scores.getOrDefault("Alice", 0));   // 90 — in map

// ── Conditional put: ─────────────────────────────────────────────────
scores.putIfAbsent("Carol", 78);   // adds Carol=78 (not present)
scores.putIfAbsent("Alice", 100);  // no change — Alice already present
System.out.println(scores.get("Carol")); // 78
System.out.println(scores.get("Alice")); // 90 — unchanged

// ── computeIfAbsent — lazily initialise: ─────────────────────────────
Map<String, List<String>> groups = new HashMap<>();
groups.computeIfAbsent("team-a", k -> new ArrayList<>()).add("Alice");
groups.computeIfAbsent("team-a", k -> new ArrayList<>()).add("Bob");
groups.computeIfAbsent("team-b", k -> new ArrayList<>()).add("Carol");
System.out.println(groups); // {team-a=[Alice, Bob], team-b=[Carol]}

// ── merge — count word frequencies: ─────────────────────────────────
String text = "the quick brown fox the fox";
Map<String, Integer> freq = new HashMap<>();
for (String word : text.split(" ")) {
    freq.merge(word, 1, Integer::sum);
}
System.out.println(freq); // {the=2, quick=1, brown=1, fox=2}

// ── compute — update with logic: ──────────────────────────────────────
scores.compute("Alice", (k, v) -> v == null ? 0 : v + 5); // 90 → 95
scores.compute("Dave",  (k, v) -> v == null ? 50 : v + 5); // null → 50

// ── replaceAll — transform all values: ────────────────────────────────
scores.replaceAll((k, v) -> v + 10);   // add 10 to every score

// ── Iteration patterns: ───────────────────────────────────────────────
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.printf("%-10s → %d%n", entry.getKey(), entry.getValue());
}

scores.forEach((name, score) -> System.out.printf("%s: %d%n", name, score));

scores.keySet().forEach(System.out::println);
scores.values().forEach(System.out::println);

// ── equals-hashCode contract — using custom key: ─────────────────────
public class Point {
    private final int x, y;

    public Point(int x, int y) { this.x = x; this.y = y; }

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

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

Map<Point, String> map = new HashMap<>();
map.put(new Point(1, 2), "origin-ish");
System.out.println(map.get(new Point(1, 2)));  // "origin-ish" — works!
// Works because Point correctly overrides both equals() and hashCode().

// ── Null key: ─────────────────────────────────────────────────────────
Map<String, Integer> m = new HashMap<>();
m.put(null, 42);
System.out.println(m.get(null));           // 42
System.out.println(m.containsKey(null));   // true

// Distinguish null-mapped from absent:
m.put("present-null", null);
System.out.println(m.get("present-null"));   // null — key IS present
System.out.println(m.get("absent-key"));     // null — key NOT present
System.out.println(m.containsKey("present-null"));  // true — is present
System.out.println(m.containsKey("absent-key"));    // false — not present

// ── Correct removal during iteration: ────────────────────────────────
Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90); scores.put("Bob", 45); scores.put("Carol", 78);

// Remove low scores using entrySet().removeIf():
scores.entrySet().removeIf(entry -> entry.getValue() < 60);
System.out.println(scores);  // {Alice=90, Carol=78}

// ── Sizing for known capacity: ────────────────────────────────────────
// Expect 1000 entries — compute initial capacity to avoid rehashing:
int expectedSize = 1000;
int initialCapacity = (int) (expectedSize / 0.75) + 1;  // ~1334
Map<String, String> sized = new HashMap<>(initialCapacity);
// This map will not resize until >1000 entries are added.