What is the difference between HashMap and HashTable?

Question

Accepted Answer

**HashMap** — not thread-safe, allows null keys/values. **HashTable** — thread-safe (synchronized), no null keys/values. HashMap is the modern choice. Analogy: **HashMap** is like a fast, unlocked filing cabinet — great for single-person use. **HashTable** is like a filing cabinet with a combination lock — safe for multiple people, but slower because everyone has to wait their turn. **HashMap (java.util.HashMap):** - **NOT thread-safe** — no synchronization (fast for single-threaded use). - **Allows null** key and null values (one null key, multiple null values). - Uses **hashing** with **linked lists** (Java 7) or **red-black trees** (Java 8+ when buckets exceed 8 elements). - Not part of the original Collection framework — added in Java 1.2. - `hashCode()` + `equals()` determine bucket placement and equality. - Default initial capacity: 16, load factor: 0.75 (resizes when 75% full). ```java HashMap map = new HashMap<>(); // Adding entries map.put("Alice", 90); map.put("Bob", 85); map.put(null, 0); // OK — null key allowed map.put("Charlie", null); // OK — null value allowed // Retrieving Integer score = map.get("Alice"); // 90 Integer missing = map.get("Eve"); // null (not found) // Checking boolean hasAlice = map.containsKey("Alice"); // true boolean hasScore = map.containsValue(90); // true // Iterating for (Map.Entry entry : map.entrySet()) { System.out.println(entry.getKey() + " = " + entry.getValue()); } // Java 8+ methods Integer val = map.getOrDefault("Eve", 0); // 0 if not found map.putIfAbsent("Alice", 100); // Only adds if key absent map.computeIfAbsent("Frank", k -> k.length() * 10); // Compute on miss // Custom capacity and load factor HashMap sized = new HashMap<>(64, 0.5f); // 64 initial buckets, resize at 50% full ``` **HashTable (java.util.Hashtable):** - **Thread-safe** — all public methods are `synchronized`. - **NO null** keys or values — throws NullPointerException. - Legacy class from Java 1.0 — predates Collections framework. - Slower due to synchronization overhead. - Use `ConcurrentHashMap` instead for thread-safe maps (much better performance). ```java Hashtable table = new Hashtable<>(); table.put("Alice", 90); table.put("Bob", 85); // table.put(null, 0); // THROWS NullPointerException! // table.put("x", null); // THROWS NullPointerException! Integer score = table.get("Alice"); // 90 // Enumerations (legacy iteration) Enumeration keys = table.keys(); while (keys.hasMoreElements()) { String key = keys.nextElement(); System.out.println(key + " = " + table.get(key)); } // Better: use Enumeration or for-each for (String key : table.keySet()) { System.out.println(key + " = " + table.get(key)); } ``` **Key differences:** - **HashMap** — not thread-safe. **HashTable** — thread-safe (synchronized). - **HashMap** — allows null keys/values. **HashTable** — no nulls. - **HashMap** — from Java 1.2. **HashTable** — from Java 1.0 (legacy). - **HashMap** — uses Iterator (fail-fast). **HashTable** — uses Enumeration. - **HashMap** — not synchronized. **HashTable** — synchronized (slower). **Which thread-safe alternative to use instead of HashTable:** - `ConcurrentHashMap` — best for concurrent reads/writes (segments-based locking). - `Collections.synchronizedMap(map)` — wraps HashMap with synchronization. ```java // Best thread-safe option ConcurrentHashMap concurrentMap = new ConcurrentHashMap<>(); concurrentMap.put("Alice", 90); concurrentMap.compute("Alice", (key, val) -> val + 5); // Thread-safe update ``` **Never use HashTable in new code** — it's legacy. Use HashMap or ConcurrentHashMap.

Java: What is the difference between HashMap and HashTable?