Java HashMap — Non-Atomic Resize Causes Infinite Loops

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

public class HashMapInternalsDemo {

    public static void main(String[] args) {

        // A product price catalogue — a perfect real-world HashMap use case
        Map<String, Double> productPrices = new HashMap<>();

        // put() computes hashCode("Laptop"), finds the right bucket, stores the pair
        productPrices.put("Laptop", 999.99);
        productPrices.put("Headphones", 149.49);
        productPrices.put("USB-C Hub", 39.95);
        productPrices.put("Webcam", 89.00);

        // get() uses the same hash logic to jump straight to the value — no loop
        double laptopPrice = productPrices.get("Laptop");
        System.out.println("Laptop price: $" + laptopPrice);

        // getOrDefault() is safer — avoids NullPointerException if key is missing
        double micPrice = productPrices.getOrDefault("Microphone", 0.0);
        System.out.println("Microphone price (not in catalogue): $" + micPrice);

        // containsKey() is O(1) — use it to check before acting
        if (productPrices.containsKey("Webcam")) {
            System.out.println("Webcam is stocked.");
        }

        // Iterating over entries — entrySet() is the most efficient way
        System.out.println("\n--- Full Product Catalogue ---");
        for (Map.Entry<String, Double> entry : productPrices.entrySet()) {
            System.out.printf("%-15s $%.2f%n", entry.getKey(), entry.getValue());
        }

        // HashMap size grows dynamically — default initial capacity is 16, load factor 0.75
        System.out.println("\nTotal products: " + productPrices.size());
    }
}

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

// Imagine a system tracking inventory per warehouse location
class WarehouseLocation {
    private final String city;
    private final int aisle;

    public WarehouseLocation(String city, int aisle) {\n        this.city = city;\n        this.aisle = aisle;\n    }

    // Without overriding equals(), two WarehouseLocation("London", 3) objects
    // are NOT considered equal — Java uses reference equality by default
    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof WarehouseLocation)) return false;
        WarehouseLocation that = (WarehouseLocation) other;
        return this.aisle == that.aisle && Objects.equals(this.city, that.city);
    }

    // Without overriding hashCode(), equal objects can land in DIFFERENT buckets
    // Objects.hash() combines fields safely into a well-distributed hash code
    @Override
    public int hashCode() {
        return Objects.hash(city, aisle);
    }

    @Override
    public String toString() {
        return city + ", Aisle " + aisle;
    }
}

public class CustomKeyHashMapDemo {\n\n    public static void main(String[] args) {\n\n        Map<WarehouseLocation, Integer> stockLevels = new HashMap<>();\n\n        WarehouseLocation londonAisle3 = new WarehouseLocation(\"London\", 3);\n        stockLevels.put(londonAisle3, 250);\n\n        // This is a DIFFERENT object in memory, but logically the same location\n        WarehouseLocation sameLocation = new WarehouseLocation(\"London\", 3);\n\n        // This works ONLY because we correctly overrode hashCode() and equals()\n        Integer stock = stockLevels.get(sameLocation);\n        System.out.println(\"Stock at \" + sameLocation + \": \" + stock + \" units\");\n\n        // Updating stock — put() with an existing key replaces the old value\n        stockLevels.put(londonAisle3, 180);\n        System.out.println(\"Updated stock: \" + stockLevels.get(sameLocation) + \" units\");\n\n        System.out.println(\"Map size (should be 1, not 2): \" + stockLevels.size());\n    }\n}",
        "output": "Stock at London, Aisle 3: 250 units\nUpdated stock: 180 units\nMap size (should be 1, not 2): 1"
      }

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

public class HashMapResizingDemo {

    public static void main(String[] args) {
        // Simulating bulk load of 1 million entries
        // Without pre-sizing: many resizes
        long start = System.currentTimeMillis();
        Map<Integer, String> map = new HashMap<>();
        for (int i = 0; i < 1_000_000; i++) {
            map.put(i, "value" + i);
        }
        System.out.println("Default init: " + (System.currentTimeMillis() - start) + "ms");

        // With pre-sizing: expected 1M / 0.75 = 1,333,333 -> next power of 2 = 2,097,152
        start = System.currentTimeMillis();
        Map<Integer, String> preSized = new HashMap<>(2_097_152);
        for (int i = 0; i < 1_000_000; i++) {
            preSized.put(i, "value" + i);
        }
        System.out.println("Pre-sized:    " + (System.currentTimeMillis() - start) + "ms");
    }
}

package io.thecodeforge.hashmap;

import java.util.*;

public class HashMapVsHashtableDemo {

    public static void main(String[] args) {
        // Hashtable — no null keys
        Hashtable<String, Integer> ht = new Hashtable<>();
        try {
            ht.put(null, 1);  // throws NullPointerException
        } catch (NullPointerException e) {
            System.out.println("Hashtable forbids null keys");
        }

        // HashMap — allows null key
        Map<String, Integer> hm = new HashMap<>();
        hm.put(null, 1);
        System.out.println("HashMap null key value: " + hm.get(null));

        // Performance comparison (single-threaded)
        long start = System.nanoTime();
        for (int i = 0; i < 100_000; i++) {
            hm.put("key" + i, i);
        }
        long hmTime = System.nanoTime() - start;

        start = System.nanoTime();
        for (int i = 0; i < 100_000; i++) {
            ht.put("key" + i, i);
        }
        long htTime = System.nanoTime() - start;

        System.out.printf("HashMap time: %d ns\nHashtable time: %d ns\n", hmTime, htTime);
    }
}

package io.thecodeforge.hashmap;

import java.util.*;

public class MapOrderingDemo {

    public static void main(String[] args) {
        Map<String, Integer> hashMap = new HashMap<>();
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        Map<String, Integer> treeMap = new TreeMap<>();

        List<String> keys = Arrays.asList("Charlie", "Alpha", "Bravo");
        for (String key : keys) {
            hashMap.put(key, key.length());
            linkedHashMap.put(key, key.length());
            treeMap.put(key, key.length());
        }

        System.out.println("HashMap (arbitrary): " + hashMap);
        System.out.println("LinkedHashMap (insertion): " + linkedHashMap);
        System.out.println("TreeMap (sorted): " + treeMap);

        // LinkedHashMap as LRU cache
        LinkedHashMap<String, Integer> lru = new LinkedHashMap<String, Integer>(16, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {\n                return size() > 3;\n            }
        };
        lru.put("A", 1);
        lru.put("B", 2);
        lru.put("C", 3);
        lru.get("A"); // Access A to make it most recent
        lru.put("D", 4); // Triggers removal of eldest (B was not accessed recently)
        System.out.println("LRU cache (access-order): " + lru);
    }
}

package io.thecodeforge;

import java.util.*;
import java.util.concurrent.*;

public class ConcurrencyComparisonDemo {

    public static void main(String[] args) throws Exception {
        // Single-writer, many-reader benchmark (simplified)
        int threads = 10;
        int iterations = 100_000;
        ExecutorService pool = Executors.newFixedThreadPool(threads);

        // Hashtable
        Map<Integer, Integer> ht = new Hashtable<>();
        long start = System.nanoTime();
        testConcurrentMap(ht, threads, iterations, pool);
        System.out.println("Hashtable: " + (System.nanoTime() - start) / 1_000_000 + "ms");

        // ConcurrentHashMap
        Map<Integer, Integer> chm = new ConcurrentHashMap<>();
        start = System.nanoTime();
        testConcurrentMap(chm, threads, iterations, pool);
        System.out.println("ConcurrentHashMap: " + (System.nanoTime() - start) / 1_000_000 + "ms");

        // Synchronized HashMap
        Map<Integer, Integer> shm = Collections.synchronizedMap(new HashMap<>());
        start = System.nanoTime();
        testConcurrentMap(shm, threads, iterations, pool);
        System.out.println("Synchronized HashMap: " + (System.nanoTime() - start) / 1_000_000 + "ms");

        pool.shutdown();
    }

    static void testConcurrentMap(Map<Integer, Integer> map, int threads, int iterations, ExecutorService pool) throws Exception {\n        CountDownLatch latch = new CountDownLatch(threads);\n        for (int t = 0; t < threads; t++) {\n            pool.submit(() -> {\n                for (int i = 0; i < iterations; i++) {\n                    map.put(i, i);\n                    map.get(i);\n                }
                latch.countDown();
            });
        }
        latch.await();
    }
}

package io.thecodeforge;

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

public class HashMapPatternsDemo {

    public static void main(String[] args) {

        // ── PATTERN 1: Frequency Counting ──────────────────────────────────
        List<String> orderCategories = Arrays.asList(
            "Electronics", "Books", "Electronics", "Clothing",
            "Books", "Electronics", "Books", "Clothing", "Toys"
        );

        Map<String, Integer> categoryCount = new HashMap<>();
        for (String category : orderCategories) {
            categoryCount.merge(category, 1, Integer::sum);
        }
        System.out.println("Order counts by category:");
        categoryCount.forEach((c, cnt) -> System.out.println("  " + c + ": " + cnt));

        // ── PATTERN 2: computeIfAbsent for Grouping ────────────────────────
        Map<String, List<Integer>> ordersByRegion = new HashMap<>();
        String[][] rawOrders = {
            {"North", "1001"}, {\"South\", \"1002\"}, {\"North\", \"1003\"},\n            {\"East\",  \"1004\"}, {\"South\", \"1005\"}, {\"North\", \"1006\"}\n        };\n        for (String[] order : rawOrders) {\n            ordersByRegion.computeIfAbsent(order[0], r -> new ArrayList<>()).add(Integer.parseInt(order[1]));\n        }\n        System.out.println(\"\\nOrders grouped by region:\");\n        ordersByRegion.forEach((r, ids) -> System.out.println(\"  \" + r + \": \" + ids));\n\n        // ── PATTERN 3: putIfAbsent for Default Configs ─────────────────────\n        Map<String, String> config = new HashMap<>();\n        config.put(\"timeout\", \"30s\");\n        config.putIfAbsent(\"timeout\",  \"60s\");   // ignored\n        config.putIfAbsent(\"retries\", \"3\");\n        System.out.println(\"\\nConfig:\");\n        config.forEach((k,v) -> System.out.println(\"  \" + k + \" = \" + v));\n\n        // ── PATTERN 4: Two-level cache ─────────────────────────────────────\n        Map<String, Map<Integer, String>> twoLevelCache = new HashMap<>();\n        // Automatically creates inner map for \"users\" on first access\n        twoLevelCache.computeIfAbsent(\"users\", k -> new HashMap<>()).put(1, \"Alice\");\n        twoLevelCache.computeIfAbsent(\"users\", k -> new HashMap<>()).put(2, \"Bob\");\n        System.out.println(\"Two-level cache: \" + twoLevelCache);\n    }\n}",
        "output": "Order counts by category:\n  Books: 3\n  Toys: 1\n  Clothing: 2\n  Electronics: 3\n\nOrders grouped by region:\n  South: [1002, 1005]\n  North: [1001, 1003, 1006]\n  East: [1004]\n\nConfig:\n  timeout = 30s\n  retries = 3\n\nTwo-level cache: {users={1=Alice, 2=Bob}}"
      }

package io.thecodeforge.hashmap;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

public class MergeMethodDemo {

    public static void main(String[] args) {
        // Word frequency counter — one line per word
        String[] words = {"apple", "banana", "apple", "cherry", "banana", "apple"};
        Map<String, Integer> freq = new HashMap<>();
        for (String word : words) {
            freq.merge(word, 1, Integer::sum);
        }
        System.out.println("Word frequencies: " + freq);

        // Summing scores per player (multiple logs)
        Map<String, Integer> totalScores = new HashMap<>();
        totalScores.merge("Alice", 10, Integer::sum);
        totalScores.merge("Bob", 20, Integer::sum);
        totalScores.merge("Alice", 5, Integer::sum);
        System.out.println("Total scores: " + totalScores);

        // Concurrent use — thread-safe accumulation
        Map<String, AtomicInteger> concurrentFreq = new ConcurrentHashMap<>();
        // With merge and AtomicInteger (not needed if using Integer and merge)
        // Actually, merge with Integer is atomic on ConcurrentHashMap
        // Simulate concurrent updates
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                concurrentFreq.merge("sharedKey", 1, Integer::sum);
            }
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        try { t1.join(); t2.join(); } catch (InterruptedException e) {}
        System.out.println("Concurrent merge result: " + concurrentFreq.get("sharedKey") + " (expected 2000)");

        // Removing a key via returning null
        Map<String, String> map = new HashMap<>();
        map.put("temp", "value");
        map.merge("temp", "irrelevant", (old, val) -> null);  // removes key
        System.out.println("After merge-to-null: " + map.containsKey("temp")); // false
    }
}

package io.thecodeforge.hashmap;

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

public class PracticeProblems {

    public static void main(String[] args) {
        // Problem 1: Word Frequency Counter
        String text = "apple banana apple cherry banana apple";
        Map<String, Integer> freq = new HashMap<>();
        for (String word : text.split(" ")) {
            freq.merge(word, 1, Integer::sum);
        }
        System.out.println("1. Word frequencies: " + freq);

        // Problem 2: Anagram Detector
        String s1 = "listen";
        String s2 = "silent";
        System.out.println("2. Are anagrams? " + areAnagrams(s1, s2));

        // Problem 3: LRU Cache
        LRUCache<String, Integer> cache = new LRUCache<>(3);
        cache.put("A", 1); cache.put("B", 2); cache.put("C", 3);
        cache.get("A"); cache.put("D", 4);
        System.out.println("3. LRU cache: " + cache);

        // Problem 4: Group Anagrams
        String[] words = {"eat", "tea", "tan", "ate", "nat", "bat"};
        System.out.println("4. Grouped anagrams: " + groupAnagrams(words));

        // Problem 5: Two Sum
        int[] nums = {2, 7, 11, 15};
        int target = 9;
        System.out.println("5. Two sum indices: " + Arrays.toString(twoSum(nums, target)));
    }

    static boolean areAnagrams(String a, String b) {\n        if (a.length() != b.length()) return false;\n        Map<Character, Integer> map = new HashMap<>();\n        for (char c : a.toCharArray()) map.merge(c, 1, Integer::sum);\n        for (char c : b.toCharArray()) {\n            if (!map.containsKey(c)) return false;\n            int count = map.get(c) - 1;\n            if (count == 0) map.remove(c);\n            else map.put(c, count);\n        }
        return map.isEmpty();
    }

    static class LRUCache<K, V> extends LinkedHashMap<K, V> {\n        private final int maxSize;\n        LRUCache(int maxSize) {\n            super(16, 0.75f, true); // access-order\n            this.maxSize = maxSize;\n        }
        @Override
        protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {\n            return size() > maxSize;\n        }
    }

    static List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for (String s : strs) {
            char[] chars = s.toCharArray();
            Arrays.sort(chars);
            String key = new String(chars);
            map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
        }
        return new ArrayList<>(map.values());
    }

    static int[] twoSum(int[] nums, int target) {\n        Map<Integer, Integer> map = new HashMap<>();\n        for (int i = 0; i < nums.length; i++) {\n            int complement = target - nums[i];\n            if (map.containsKey(complement)) {\n                return new int[]{map.get(complement), i};
            }
            map.put(nums[i], i);
        }
        return new int[]{};
    }
}

// io.thecodeforge — java tutorial

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

public class HashMapConstructorPitfall {
    public static void main(String[] args) {
        // Wrong: default capacity 16, resizes after 12 entries
        Map<String, String> fragileMap = new HashMap<>();
        for (int i = 0; i < 1000; i++) {
            fragileMap.put("key-" + i, "value-" + i);
        }
        // ~7 resizes happened, each copying all entries

        // Right: pre-allocate for 1000 entries with load factor 0.75
        int expectedSize = 1000;
        int capacity = (int)(expectedSize / 0.75 + 1);
        Map<String, String> solidMap = new HashMap<>(capacity);
        for (int i = 0; i < 1000; i++) {
            solidMap.put("key-" + i, "value-" + i);
        }
        // Zero resizes

        System.out.println("solidMap size: " + solidMap.size());
    }
}

// io.thecodeforge — java tutorial

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

class BrokenHashKey {
    final int id;
    BrokenHashKey(int id) { this.id = id; }
    @Override public int hashCode() { return 1; } // all collide!
    @Override public boolean equals(Object o) {
        if (!(o instanceof BrokenHashKey)) return false;
        return ((BrokenHashKey)o).id == this.id;
    }
}

public class TreeificationThreshold {
    public static void main(String[] args) {
        Map<BrokenHashKey, String> badMap = new HashMap<>();
        for (int i = 0; i < 20; i++) {
            badMap.put(new BrokenHashKey(i), "val-" + i);
        }
        // After 8 entries in bucket 1, HashMap treeifies that bucket
        // get() switches from O(n) to O(log n)
        System.out.println("Retrieved: " + badMap.get(new BrokenHashKey(5)));
    }
}

// io.thecodeforge — java tutorial

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

public class IterationOrderBreakdown {
    public static void main(String[] args) {
        Map<String, Integer> orders = new HashMap<>();
        orders.put("alpha", 1);
        orders.put("beta", 2);
        orders.put("gamma", 3);

        // First iteration — order may be alpha, beta, gamma or different
        System.out.print("First: ");
        orders.keySet().forEach(k -> System.out.print(k + " "));
        System.out.println();

        // Simulate resize by adding many entries
        for (int i = 0; i < 1000; i++) {
            orders.put("x-" + i, i);
        }

        // Second iteration — order likely changed!
        System.out.print("After resize: ");
        orders.keySet().forEach(k -> System.out.print(k + " "));
        System.out.println();
    }
}

// io.thecodeforge — java tutorial

import java.util.*;

public class HashMapComplexity {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>(1 << 20); // 1M capacity
        long start = System.nanoTime();
        for (int i = 0; i < 1_000_000; i++) {
            map.put(i, "value-" + i);
        }
        long end = System.nanoTime();
        System.out.printf("Insert 1M entries: %d ms%n", (end - start) / 1_000_000);

        start = System.nanoTime();
        String val = map.get(500_000);
        end = System.nanoTime();
        System.out.printf("Get entry: %d ns%n", (end - start));
    }
}

// io.thecodeforge — java tutorial

import java.util.*;

public class HashMapCopyConstructor {
    public static void main(String[] args) {
        Map<String, Integer> original = new HashMap<>();
        original.put("alice", 1);
        original.put("bob", 2);

        // Shallow copy — shares references
        Map<String, Integer> copy = new HashMap<>(original);

        // Mutate original after copy
        original.put("alice", 100);
        original.put("charlie", 3);

        System.out.println("Original: " + original);
        System.out.println("Copy:     " + copy);
        // String values are immutable, so copy is unaffected
        // But with mutable keys (e.g., List), both maps corrupt
    }
}