HashMap Internals

HashMap is fast and not thread-safe; Hashtable is legacy with coarse locking; ConcurrentHashMap is the modern thread-safe map with per-bucket locking and lock-free reads.

HashMap is faster but not thread-safe and allows null; ConcurrentHashMap is thread-safe with lock-free reads, per-bucket write locking, atomic compound operations, and no null.

Collections.synchronizedMap wraps a HashMap with a single mutex that synchronizes every operation, but iteration still requires manual external synchronization and compound operations are not atomic.

HashMap uses a bucket array where each entry's position is determined by its key's hash code; collisions chain as linked lists that convert to Red-Black trees at 8 nodes, and the table resizes at 75% capacity.

When two keys hash to the same bucket, HashMap chains them in a linked list; at 8 nodes the chain converts to a Red-Black tree (Java 8+) for O(log n) lookup instead of O(n).

put() with an existing key replaces the old value and returns it; the key object is not replaced, the size stays the same, and putIfAbsent only inserts if the key is absent.

Mutating a HashMap key after insertion changes its hashCode, causing the entry to become permanently unreachable – get() returns null, but the entry still exists as a memory leak.

entrySet() gives key-value pairs directly in one traversal; keySet()+get() does a second hash lookup for every key, doubling the work.

Java 7 ConcurrentHashMap used 16 segment locks; Java 8+ uses CAS for empty buckets, synchronized per-bucket for non-empty ones, lock-free volatile reads, and distributed concurrent resize.

HashMap resizes by doubling capacity (always power-of-2) and redistributing entries using a one-bit check: hash & oldCapacity determines if an entry stays at its index or moves to index + oldCapacity.