Java HashMap

// Simplified representation of HashMap's internal Node (Java 8+)
static class Node<K, V> implements Map.Entry<K, V> {
    final int    hash;   // cached hash of the key
    final K      key;    // the key — may be null (stored at index 0)
    V            value;  // the value — may be null
    Node<K,V>    next;   // next node in the same bucket chain
}

// When chain length > TREEIFY_THRESHOLD (8) AND table.length >= 64:
// Node<K,V> is promoted to TreeNode<K,V> — a Red-Black Tree node
static final class TreeNode<K, V> extends LinkedHashMap.Entry<K, V> {
    TreeNode<K,V> parent, left, right, prev;
    boolean red;
}

// Core internal state of HashMap:
transient Node<K,V>[] table;     // the bucket array (length always power of two)
transient int         size;       // total number of key-value entries
int                   threshold;  // size at which rehash occurs (capacity × loadFactor)
final float           loadFactor; // default 0.75f

// Key constants:
static final int DEFAULT_INITIAL_CAPACITY = 16;   // must be power of two
static final int MAXIMUM_CAPACITY         = 1 << 30;
static final float DEFAULT_LOAD_FACTOR    = 0.75f;
static final int TREEIFY_THRESHOLD        = 8;    // chain → tree
static final int UNTREEIFY_THRESHOLD      = 6;    // tree → chain
static final int MIN_TREEIFY_CAPACITY     = 64;   // table must be this big to treeify

  Step 1: Null check         →  if (key == null) → store at index 0 (special path)
  Step 2: Hash spreading     →  hash = key.hashCode() ^ (key.hashCode() >>> 16)
                                (XOR high bits into low bits to improve distribution)
  Step 3: Find bucket index  →  index = hash & (table.length - 1)  (fast bitwise AND)
  Step 4: Check bucket chain →  scan linked list / tree for key using equals()
            If key found        →  update value, return old value
            If not found        →  append new Node to chain / insert into tree
  Step 5: Check treeify      →  if chain length ≥ TREEIFY_THRESHOLD (8)
                                AND table.length ≥ MIN_TREEIFY_CAPACITY (64)
                                → convert chain to Red-Black Tree
  Step 6: Check threshold    →  if ++size > threshold → resize() [double capacity]

  Bucket Array (capacity = 16):
  ┌──────┐
  │   0  │ → [null key entry]  ← only null key goes here
  │   1  │ → null
  │   2  │ → ["city"="Mumbai"] → null
  │   3  │ → null
  │   4  │ → ["name"="Ravi"] → ["dept"="Finance"] → null  ← chain (collision)
  │   5  │ → null
  │   6  │ → ["id"="201"] → null
  │  ... │
  │  15  │ → null
  └──────┘

  After Java 8 treeification (if bucket 4 chain grows > 8 AND table.length >= 64):
  │   4  │ → [Red-Black Tree root] → O(log n) lookup instead of O(n)

import java.util.*;

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

        // 1. Default constructor: capacity=16, loadFactor=0.75
        HashMap<String, Integer> hm1 = new HashMap<>();

        // 2. Specify initial capacity
        //    Useful when approximate size is known in advance
        HashMap<String, String> hm2 = new HashMap<>(50);

        // 3. Specify both initial capacity and load factor
        //    loadFactor=0.6 → rehash at 60% fill (fewer collisions, more memory)
        HashMap<String, Double> hm3 = new HashMap<>(100, 0.6f);

        // 4. Initialize from an existing Map
        Map<String, Integer> source = new Hashtable<>();
        source.put("Java",   1);
        source.put("Kotlin", 2);
        HashMap<String, Integer> hm4 = new HashMap<>(source);
        System.out.println("From map: " + hm4);

        // Best practice: declare as Map interface reference
        Map<String, String> config = new HashMap<>();
        config.put("host", "localhost");
        config.put("port", "9090");
        config.put("env",  "production");
        System.out.println("Config: " + config);

        // ✅ null key is allowed — stored at bucket index 0
        hm1.put(null, 99);
        System.out.println("Null key value: " + hm1.get(null));

        // ✅ null value is allowed
        hm1.put("unset", null);
        System.out.println("Null value for 'unset': " + hm1.get("unset"));
    }
}

import java.util.*;

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

        HashMap<String, Integer> population = new HashMap<>();

        // put() — add entries
        population.put("Mumbai",    20_667_000);
        population.put("Delhi",     32_941_000);
        population.put("Bangalore", 13_193_000);
        population.put("Chennai",    7_088_000);
        System.out.println("Cities: " + population);

        // get()
        System.out.println("Delhi population: " + population.get("Delhi"));

        // containsKey() and containsValue()
        System.out.println("Has Mumbai: " + population.containsKey("Mumbai"));
        System.out.println("Pop 7088000 exists: " + population.containsValue(7_088_000));

        // getOrDefault() — Java 8
        System.out.println("Pune: " + population.getOrDefault("Pune", -1));

        // putIfAbsent() — Java 8
        population.putIfAbsent("Delhi", 0);      // Delhi exists — no change
        population.putIfAbsent("Pune", 7_764_000); // Pune is new — inserted
        System.out.println("After putIfAbsent: Delhi=" + population.get("Delhi")
                            + ", Pune=" + population.get("Pune"));

        // replace()
        population.replace("Chennai", 7_200_000);
        System.out.println("Updated Chennai: " + population.get("Chennai"));

        // compute() — Java 8: add 500_000 to Bangalore's population
        population.compute("Bangalore", (city, pop) -> pop + 500_000);
        System.out.println("Computed Bangalore: " + population.get("Bangalore"));

        // merge() — Java 8: useful for accumulating values
        population.merge("Mumbai", 1_000_000, Integer::sum);
        System.out.println("Merged Mumbai: " + population.get("Mumbai"));

        // remove()
        population.remove("Pune");
        System.out.println("After remove Pune: " + population.containsKey("Pune"));

        // forEach — Java 8
        System.out.println("--- All Cities ---");
        population.forEach((city, pop) ->
            System.out.printf("%-12s → %,d%n", city, pop));
    }
}

import java.util.*;

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

        // Strategy 1: Default — rehashing may occur
        HashMap<String, String> defaultMap = new HashMap<>();
        // Threshold = 16 × 0.75 = 12 → rehashes at 13th entry

        // Strategy 2: Pre-sized — no rehashing for up to 1000 entries
        // initialCapacity = 1000 / 0.75 + 1 = 1335 (rounded to next power of two: 2048)
        HashMap<String, String> preSeized = new HashMap<>(1335);

        // Strategy 3: High-speed cache — sparse table, fewer collisions
        HashMap<String, String> fastCache = new HashMap<>(256, 0.5f);

        // Populate pre-sized map
        for (int i = 1; i <= 1000; i++) {
            preSeized.put("key-" + i, "value-" + i);
        }
        System.out.println("Pre-sized entries: " + preSeized.size());
        System.out.println("No rehashing occurred — table pre-sized correctly.");
    }
}

import java.util.*;

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

        HashMap<String, String> map = new HashMap<>();

        // ✅ One null key — always stored at bucket index 0
        map.put(null, "default config");
        System.out.println("null key → " + map.get(null));

        // Overwrite null key (same as any other key)
        map.put(null, "updated config");
        System.out.println("null key (overwritten) → " + map.get(null));

        // ✅ Multiple null values
        map.put("primaryColor",   null);
        map.put("secondaryColor", null);
        map.put("accentColor",    "#FF5733");
        System.out.println("primaryColor → " + map.get("primaryColor"));

        // ⚠️ TRAP: get() returns null for BOTH absent keys AND null-value keys
        // Use containsKey() to distinguish them:
        System.out.println("get missing key: " + map.get("missingKey"));    // null
        System.out.println("get null-value key: " + map.get("primaryColor")); // null
        // Both return null — but the meaning is different!

        // Correct approach: containsKey() to distinguish
        String key = "primaryColor";
        if (map.containsKey(key)) {
            System.out.println(key + " is set (value may be null): " + map.get(key));
        } else {
            System.out.println(key + " does not exist in map");
        }

        // getOrDefault() avoids null-value ambiguity for absent keys
        System.out.println("font: " + map.getOrDefault("font", "Arial"));
    }
}

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

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

        HashMap<String, Double> gpa = new HashMap<>();
        gpa.put("Arjun",  8.9);
        gpa.put("Sneha",  9.4);
        gpa.put("Vikram", 7.8);
        gpa.put("Pooja",  9.1);

        // 1. entrySet() with for-each — RECOMMENDED: accesses both key and value
        System.out.println("--- entrySet ---");
        for (Map.Entry<String, Double> entry : gpa.entrySet()) {
            System.out.println(entry.getKey() + " → " + entry.getValue());
        }

        // 2. keySet() — only when keys alone are needed
        System.out.println("--- keySet ---");
        for (String name : gpa.keySet()) {
            System.out.println(name + " : " + gpa.get(name));
        }

        // 3. values() — iterate values only
        System.out.println("--- values ---");
        for (double score : gpa.values()) {
            System.out.println(score);
        }

        // 4. forEach with lambda (Java 8+) — cleanest
        System.out.println("--- forEach lambda ---");
        gpa.forEach((name, score) ->
            System.out.printf("%-8s GPA: %.1f%n", name, score));

        // 5. Stream API — filter and process
        System.out.println("--- Stream: GPA > 9.0 ---");
        gpa.entrySet().stream()
           .filter(e -> e.getValue() > 9.0)
           .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
           .forEach(e -> System.out.println(e.getKey() + " → " + e.getValue()));

        // ⚠️ HashMap's Iterator is FAIL-FAST.
        // Modifying the map during iteration throws ConcurrentModificationException.
        // Safe removal during iteration: use Iterator.remove()
        System.out.println("--- Safe removal during iteration ---");
        Iterator<Map.Entry<String, Double>> it = gpa.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Double> e = it.next();
            if (e.getValue() < 8.0) {
                it.remove();  // safe — removes from underlying map
                System.out.println("Removed: " + e.getKey());
            }
        }
        System.out.println("After removal: " + gpa);
    }
}

import java.util.*;

class EmployeeId {
    private final String department;
    private final int    empNumber;

    EmployeeId(String department, int empNumber) {
        this.department = department;
        this.empNumber  = empNumber;
    }

    // MUST override equals — HashMap uses this to find keys in bucket chains
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof EmployeeId)) return false;
        EmployeeId other = (EmployeeId) o;
        return empNumber == other.empNumber
               && department.equals(other.department);
    }

    // MUST override hashCode — determines which bucket the key lands in
    // Contract: if a.equals(b) then a.hashCode() == b.hashCode()
    @Override
    public int hashCode() {
        return Objects.hash(department, empNumber);
    }

    @Override
    public String toString() {
        return department + "-" + empNumber;
    }
}

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

        HashMap<EmployeeId, String> directory = new HashMap<>();
        directory.put(new EmployeeId("TECH", 1001), "Ananya Sharma");
        directory.put(new EmployeeId("TECH", 1002), "Rohan Mehta");
        directory.put(new EmployeeId("HR",   2001), "Kavya Reddy");

        // Lookup with a NEW EmployeeId object — same field values
        // Succeeds ONLY because hashCode() and equals() are correctly overridden
        String name = directory.get(new EmployeeId("TECH", 1001));
        System.out.println("Found: " + name);

        // Without overriding hashCode/equals, this would return null
        // because two different object instances would land in different buckets

        directory.forEach((id, empName) ->
            System.out.println(id + " => " + empName));
    }
}

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

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

        String text = "the quick brown fox jumps over the lazy dog " +
                      "the dog barked at the fox and the fox ran away";

        HashMap<String, Integer> freq = new HashMap<>();

        // Count frequencies using merge() — cleanest approach
        for (String word : text.split("\\s+")) {
            freq.merge(word, 1, Integer::sum);
        }

        System.out.println("All word frequencies:");
        freq.forEach((word, count) ->
            System.out.printf("  %-10s : %d%n", word, count));

        // Top 3 most frequent words using Stream API
        System.out.println("\nTop 3 words:");
        freq.entrySet().stream()
           .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
           .limit(3)
           .forEach(e ->
               System.out.printf("  %-10s : %d times%n", e.getKey(), e.getValue()));
    }
}

import java.util.*;

public class GroupByDepartment {

    record Student(String name, String dept, double gpa) {}

    public static void main(String[] args) {

        List<Student> students = List.of(
            new Student("Arjun",   "CS",      8.9),
            new Student("Sneha",   "ECE",     9.2),
            new Student("Vikram",  "CS",      7.8),
            new Student("Pooja",   "MECH",    8.5),
            new Student("Rahul",   "ECE",     8.1),
            new Student("Priya",   "CS",      9.5),
            new Student("Aditya",  "MECH",    7.3)
        );

        // Group students by department — computeIfAbsent avoids null check + put
        HashMap<String, List<String>> byDept = new HashMap<>();
        for (Student s : students) {
            byDept.computeIfAbsent(s.dept(), k -> new ArrayList<>())
                  .add(s.name() + " (" + s.gpa() + ")");
        }

        // Print grouped results
        System.out.println("Students by Department:");
        byDept.entrySet().stream()
              .sorted(Map.Entry.comparingByKey())
              .forEach(e -> {
                  System.out.println("  " + e.getKey() + ":");
                  e.getValue().forEach(s -> System.out.println("    → " + s));
              });

        // Average GPA per department using merge()
        HashMap<String, Double> totalGpa   = new HashMap<>();
        HashMap<String, Integer> deptCount = new HashMap<>();
        for (Student s : students) {
            totalGpa.merge(s.dept(),   s.gpa(), Double::sum);
            deptCount.merge(s.dept(),  1,       Integer::sum);
        }
        System.out.println("\nAverage GPA by Department:");
        totalGpa.forEach((dept, total) ->
            System.out.printf("  %-6s : %.2f%n", dept, total / deptCount.get(dept)));
    }
}