Java HashMap Explained — How It Works, When to Use It, and What to Watch Out For

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) {
        this.city = city;
        this.aisle = aisle;
    }

    // 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 {

    public static void main(String[] args) {

        Map<WarehouseLocation, Integer> stockLevels = new HashMap<>();

        WarehouseLocation londonAisle3 = new WarehouseLocation("London", 3);
        stockLevels.put(londonAisle3, 250);

        // This is a DIFFERENT object in memory, but logically the same location
        WarehouseLocation sameLocation = new WarehouseLocation("London", 3);

        // This works ONLY because we correctly overrode hashCode() and equals()
        Integer stock = stockLevels.get(sameLocation);
        System.out.println("Stock at " + sameLocation + ": " + stock + " units");

        // Updating stock — put() with an existing key replaces the old value
        stockLevels.put(londonAisle3, 180);
        System.out.println("Updated stock: " + stockLevels.get(sameLocation) + " units");

        System.out.println("Map size (should be 1, not 2): " + stockLevels.size());
    }
}

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

public class HashMapPatternsDemo {

    public static void main(String[] args) {

        // ── PATTERN 1: Frequency Counting ──────────────────────────────────
        // Count how many times each product category appears in an order log
        List<String> orderCategories = Arrays.asList(
            "Electronics", "Books", "Electronics", "Clothing",
            "Books", "Electronics", "Books", "Clothing", "Toys"
        );

        Map<String, Integer> categoryCount = new HashMap<>();

        for (String category : orderCategories) {
            // merge() handles both the 'first occurrence' and 'subsequent' cases cleanly
            // If key absent: insert 1. If key present: add 1 to existing value.
            categoryCount.merge(category, 1, Integer::sum);
        }

        System.out.println("Order counts by category:");
        categoryCount.forEach((category, count) ->
            System.out.println("  " + category + ": " + count + " orders")
        );

        // ── PATTERN 2: computeIfAbsent for Grouping ────────────────────────
        // Group customer order IDs by their region
        Map<String, List<Integer>> ordersByRegion = new HashMap<>();

        String[][] rawOrders = {
            {"North", "1001"}, {"South", "1002"}, {"North", "1003"},
            {"East",  "1004"}, {"South", "1005"}, {"North", "1006"}
        };

        for (String[] order : rawOrders) {
            String region  = order[0];
            int    orderId = Integer.parseInt(order[1]);

            // computeIfAbsent creates a new ArrayList for a region the first time we see it,
            // then returns the existing list for subsequent calls — no null check needed
            ordersByRegion.computeIfAbsent(region, r -> new ArrayList<>()).add(orderId);
        }

        System.out.println("\nOrders grouped by region:");
        ordersByRegion.forEach((region, ids) ->
            System.out.println("  " + region + ": " + ids)
        );

        // ── PATTERN 3: putIfAbsent for Default Configs ─────────────────────
        Map<String, String> appConfig = new HashMap<>();
        appConfig.put("timeout", "30s");   // already configured

        // putIfAbsent only sets the value if the key isn't already present
        // Safe way to apply defaults without overwriting user-defined values
        appConfig.putIfAbsent("timeout",  "60s");   // ignored — key exists
        appConfig.putIfAbsent("retries",  "3");      // inserted — key absent
        appConfig.putIfAbsent("logLevel", "INFO");   // inserted — key absent

        System.out.println("\nApp configuration:");
        appConfig.forEach((key, value) -> System.out.println("  " + key + " = " + value));
    }
}