Java Hashtable

// Simplified representation of Hashtable's internal Entry
private static class Entry<K, V> implements Map.Entry<K, V> {
    final int   hash;   // cached hash of the key
    final K     key;    // the key — never null
    V           value;  // the value — never null
    Entry<K,V>  next;   // next entry in the same bucket (chaining)
}

// Core internal state of Hashtable:
private transient Entry<?,?>[] table;   // the bucket array
private transient int count;             // total number of entries
private int threshold;                   // count at which rehash occurs (capacity × loadFactor)
private float loadFactor;                // default 0.75f

// Default construction: capacity=11, loadFactor=0.75
// threshold = 11 × 0.75 = 8  →  rehash when 9th entry is added

  Step 1: Compute hash  →  hash = key.hashCode()  (null key → NullPointerException)
  Step 2: Find bucket   →  index = (hash & 0x7FFFFFFF) % table.length
  Step 3: Check bucket  →  scan linked-list chain for existing key (equals check)
            If key found  →  update value, return old value
            If not found  →  prepend new Entry to chain head
  Step 4: Check threshold →  if ++count > threshold  →  rehash()

  Bucket Array (capacity = 11):
  ┌─────┐
  │  0  │ → null
  │  1  │ → ["city"="Delhi"] → null
  │  2  │ → null
  │  3  │ → ["name"="Rahul"] → ["dept"="Eng"] → null  ← collision chain
  │  4  │ → null
  │  5  │ → ["id"="101"] → null
  │ ... │
  └─────┘

import java.util.*;

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

        // 1. Default constructor: capacity=11, loadFactor=0.75
        Hashtable<String, Integer> ht1 = new Hashtable<>();

        // 2. Specify initial capacity (useful when size is known)
        Hashtable<String, String> ht2 = new Hashtable<>(50);

        // 3. Specify both initial capacity and load factor
        //    loadFactor=0.5 means rehash at 50% fill — fewer collisions, more memory
        Hashtable<String, Double> ht3 = new Hashtable<>(100, 0.5f);

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

        // Using Map interface reference (recommended)
        Map<String, String> config = new Hashtable<>();
        config.put("host", "localhost");
        config.put("port", "8080");
        System.out.println("Config: " + config);

        // ❌ NullPointerException — null key not allowed
        // ht1.put(null, 1);

        // ❌ NullPointerException — null value not allowed
        // ht1.put("key", null);
    }
}

import java.util.*;

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

        Hashtable<String, Integer> scores = new Hashtable<>();

        // put() — add entries
        scores.put("Alice",  92);
        scores.put("Bob",    78);
        scores.put("Charlie",85);
        scores.put("Diana",  95);
        System.out.println("Scores: " + scores);

        // get()
        System.out.println("Alice's score: " + scores.get("Alice"));

        // containsKey() and containsValue()
        System.out.println("Has Bob: "    + scores.containsKey("Bob"));
        System.out.println("Score 85 exists: " + scores.containsValue(85));

        // getOrDefault() — Java 8
        System.out.println("Eve's score: " + scores.getOrDefault("Eve", 0));

        // putIfAbsent() — Java 8
        scores.putIfAbsent("Bob", 99);  // Bob already exists — no change
        scores.putIfAbsent("Eve", 88);  // Eve is new — inserted
        System.out.println("After putIfAbsent: " + scores);

        // replace()
        scores.replace("Charlie", 90);
        System.out.println("After replace Charlie: " + scores);

        // remove()
        scores.remove("Diana");
        System.out.println("After remove Diana: " + scores);

        // size() and isEmpty()
        System.out.println("Size: " + scores.size());
        System.out.println("Empty: " + scores.isEmpty());

        // forEach — Java 8
        System.out.println("--- All Scores ---");
        scores.forEach((name, score) ->
            System.out.println(name + " → " + score));
    }
}

import java.util.*;

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

        // Expected to store ~100 entries
        // Set initial capacity to avoid any rehashing:
        // initialCapacity = expectedSize / loadFactor + 1 = 100 / 0.75 + 1 ≈ 135
        Hashtable<String, String> ht = new Hashtable<>(135, 0.75f);

        // Now inserting 100 entries will never trigger rehashing
        for (int i = 1; i <= 100; i++) {
            ht.put("key-" + i, "value-" + i);
        }
        System.out.println("Entries: " + ht.size());  // 100
        System.out.println("No rehashing occurred — table pre-sized correctly.");
    }
}

import java.util.*;

public class HashtableThreadSafety {
    public static void main(String[] args) throws InterruptedException {

        Hashtable<String, Integer> ht = new Hashtable<>();
        ht.put("counter", 0);

        // Two threads simultaneously incrementing the counter
        Runnable incrementTask = () -> {
            for (int i = 0; i < 1000; i++) {
                // get and put are individually synchronized —
                // but the compound operation is NOT atomic!
                int current = ht.get("counter");
                ht.put("counter", current + 1);
            }
        };

        Thread t1 = new Thread(incrementTask);
        Thread t2 = new Thread(incrementTask);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // Result is NOT guaranteed to be 2000!
        // Individual get() and put() are synchronized,
        // but the get-then-put compound action is a race condition.
        System.out.println("Final counter: " + ht.get("counter"));
        System.out.println("Expected: 2000 — actual may differ due to race condition.");

        // CORRECT approach for atomic compound operations:
        // Use ConcurrentHashMap with compute() or AtomicInteger
    }
}

import java.util.*;

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

        Hashtable<String, String> ht = new Hashtable<>();
        ht.put("IN", "India");
        ht.put("US", "United States");
        ht.put("JP", "Japan");
        ht.put("DE", "Germany");

        // 1. entrySet() — most common, access both key and value
        System.out.println("--- entrySet ---");
        for (Map.Entry<String, String> entry : ht.entrySet()) {
            System.out.println(entry.getKey() + " → " + entry.getValue());
        }

        // 2. keySet() — iterate keys, fetch values
        System.out.println("--- keySet ---");
        for (String code : ht.keySet()) {
            System.out.println(code + " : " + ht.get(code));
        }

        // 3. values() — iterate values only
        System.out.println("--- values ---");
        for (String country : ht.values()) {
            System.out.println(country);
        }

        // 4. forEach with lambda (Java 8+) — cleanest approach
        System.out.println("--- forEach lambda ---");
        ht.forEach((code, country) ->
            System.out.println(code + " = " + country));

        // 5. Legacy Enumeration (keys) — avoid in new code
        System.out.println("--- Legacy Enumeration ---");
        Enumeration<String> keys = ht.keys();
        while (keys.hasMoreElements()) {
            String k = keys.nextElement();
            System.out.println(k + " -> " + ht.get(k));
        }

        // ⚠️ NOTE: Hashtable iterators are fail-fast.
        // Modifying the table during iteration (except via iterator.remove())
        // throws ConcurrentModificationException.
    }
}

import java.util.*;

class ProductId {
    private final String category;
    private final int    number;

    ProductId(String category, int number) {
        this.category = category;
        this.number   = number;
    }

    // MUST override equals — Hashtable uses this to find keys in chains
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ProductId)) return false;
        ProductId other = (ProductId) o;
        return number == other.number && category.equals(other.category);
    }

    // MUST override hashCode — determines which bucket the key lands in
    @Override
    public int hashCode() {
        return Objects.hash(category, number);
    }

    @Override
    public String toString() {
        return category + "-" + number;
    }
}

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

        Hashtable<ProductId, String> catalog = new Hashtable<>();
        catalog.put(new ProductId("ELEC", 1001), "Wireless Headphones");
        catalog.put(new ProductId("ELEC", 1002), "Bluetooth Speaker");
        catalog.put(new ProductId("HOME", 2001), "Coffee Maker");

        // Lookup using a NEW ProductId object with same values
        // Works only because equals() and hashCode() are correctly overridden
        String product = catalog.get(new ProductId("ELEC", 1001));
        System.out.println("Found: " + product);

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

import java.util.*;

class SessionStore {

    // Hashtable provides built-in thread safety for concurrent session access
    private final Hashtable<String, String> sessions = new Hashtable<>();

    public void createSession(String sessionId, String username) {
        sessions.put(sessionId, username);
        System.out.println("Session created: " + sessionId + " → " + username);
    }

    public String getUser(String sessionId) {
        return sessions.getOrDefault(sessionId, "ANONYMOUS");
    }

    public void invalidate(String sessionId) {
        String user = sessions.remove(sessionId);
        if (user != null) {
            System.out.println("Session invalidated for: " + user);
        }
    }

    public boolean isActive(String sessionId) {
        return sessions.containsKey(sessionId);
    }

    public int activeSessions() {
        return sessions.size();
    }
}

public class SessionApp {
    public static void main(String[] args) {
        SessionStore store = new SessionStore();

        store.createSession("SID-001", "rahul@example.com");
        store.createSession("SID-002", "priya@example.com");
        store.createSession("SID-003", "amit@example.com");

        System.out.println("User for SID-001: " + store.getUser("SID-001"));
        System.out.println("SID-999 active: "  + store.isActive("SID-999"));
        System.out.println("Active sessions: " + store.activeSessions());

        store.invalidate("SID-002");
        System.out.println("Active sessions after logout: " + store.activeSessions());
    }
}

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

public class MigrationDemo {

    // ❌ OLD — Legacy Hashtable (coarse locking, no nulls, poor concurrency)
    static void legacyApproach() {
        Hashtable<String, Integer> inventory = new Hashtable<>();
        inventory.put("Laptop",  50);
        inventory.put("Monitor", 30);
        inventory.put("Keyboard", 100);

        // Check-and-update is NOT atomic — race condition risk
        if (inventory.containsKey("Laptop")) {
            inventory.put("Laptop", inventory.get("Laptop") - 1);
        }
        System.out.println("[Legacy] Laptop stock: " + inventory.get("Laptop"));
    }

    // ✅ NEW — ConcurrentHashMap (fine-grained locking, atomic compound ops)
    static void modernApproach() {
        ConcurrentHashMap<String, Integer> inventory = new ConcurrentHashMap<>();
        inventory.put("Laptop",  50);
        inventory.put("Monitor", 30);
        inventory.put("Keyboard", 100);

        // compute() is fully atomic — no race condition
        inventory.compute("Laptop", (key, qty) -> (qty != null && qty > 0) ? qty - 1 : 0);
        System.out.println("[Modern] Laptop stock: " + inventory.get("Laptop"));
    }

    public static void main(String[] args) {
        legacyApproach();
        modernApproach();
    }
}