Map Implementations

LinkedHashMap is a HashMap that also remembers the order you put entries in, so iterating returns them in insertion order. A plain HashMap gives no order guarantee and can appear random.

Map.Entry represents one key-value pair in a Map. You get all pairs with map.entrySet() and loop over them, calling getKey() and getValue() on each entry. This is the cheapest way to read both key and value together.

getOrDefault(key, fallback) returns the value if the key exists, otherwise the fallback — without changing the map. putIfAbsent(key, value) only stores the value if the key is missing (or maps to null) and returns the previous value, leaving an existing value untouched.

Hashtable is an old key-value map that is thread-safe because every method is synchronized, and it refuses null keys and null values. HashMap is newer, faster, allows one null key and null values, but is not thread-safe.

A TreeMap is a Map that keeps its keys sorted. HashMap has no order and is faster for plain get/put; LinkedHashMap keeps insertion order. TreeMap sorts keys (natural order or a Comparator) and is a bit slower.

Capacity is the number of buckets (default 16). Load factor (default 0.75) is how full the map gets before it grows. When entries exceed capacity x load factor (the threshold), the map doubles its capacity and re-spreads entries so buckets stay short and lookups stay fast.

HashMap allows one null key (stored in bucket 0) and any number of null values. Its iteration order is undefined and can change after a resize, so never rely on it. It is not thread-safe: concurrent modification can corrupt it or loop forever, so use ConcurrentHashMap for shared access.

computeIfAbsent(key, fn) returns the existing value for key, or if it is missing, runs fn to create a value, stores it, and returns it. It is perfect for grouping: it makes the empty list once, then you add to it.

NavigableMap adds nearest-key lookups. For a key k: floorKey returns the largest key ≤ k, ceilingKey the smallest key ≥ k, lowerKey the largest key strictly < k, higherKey the smallest key strictly > k. The *Entry versions return the whole entry, or null if none exists.

Create a LinkedHashMap in access-order mode and override removeEldestEntry to return true once the map grows past your size limit. After each insert, the map then automatically drops the least-recently-used entry.

Access-order mode makes LinkedHashMap move an entry to the end of its list every time you read or update it, so the least-recently-used entries stay at the front. You turn it on with the three-argument constructor passing true.

computeIfAbsent runs only when the key is missing. computeIfPresent runs only when the key already has a value. compute always runs and receives the current value (or null). In all three, returning null removes (or skips creating) the entry.

merge(key, value, fn) stores value if the key is absent; if the key already has a value, it calls fn(oldValue, value) and stores the result. It is the clean way to count: counts.merge(word, 1, Integer::sum).

EnumMap is a special map whose keys must be values of one enum type. Internally it's just an array indexed by each enum's position, so it's very fast and compact, and it keeps entries in the enum's declared order.

IdentityHashMap treats two keys as the same only when they are literally the same object (==), not when they are merely equal (.equals()). So two distinct strings with identical text are two different keys.

TreeMap is backed by a red-black tree, a self-balancing binary search tree. Because the tree keeps itself roughly balanced, its height stays around log n, so finding, inserting, or removing a key takes O(log n) steps.

HashMap picks a bucket with (capacity - 1) & hash, a fast bitmask that works because capacity is a power of two. But that mask only looks at the low bits, so HashMap first mixes each key's high bits down by XOR-ing hash with (hash >>> 16). This spreads keys more evenly and avoids clustering.

In Java 8+, if too many keys collide into one bucket, HashMap turns that bucket's linked list into a balanced red-black tree so lookups in it become O(log n) instead of O(n). It happens when a bucket reaches 8 entries, but only if total capacity is at least 64.

removeEldestEntry is a hook LinkedHashMap calls after each insertion, passing the oldest entry in its list. If your override returns true, LinkedHashMap removes that oldest entry; the default returns false, so nothing is auto-removed.

On a ConcurrentHashMap, compute, computeIfAbsent, computeIfPresent, and merge perform the read-modify-write for a key as one atomic step, so two threads can't lose each other's updates. Plain get-then-put can; that's the bug they fix.

Pick by the special requirement: EnumMap for enum keys (fast, ordered), WeakHashMap when entries should disappear once keys are unused, IdentityHashMap when keys must match by identity (==), and avoid Hashtable (legacy) — use HashMap or ConcurrentHashMap.

WeakHashMap holds its keys with weak references, so once nothing else points to a key, the garbage collector can remove it and its entry disappears automatically. It's handy for caches that should not keep objects alive.

TreeMap decides whether two keys are 'the same' using compare()/compareTo, not equals(). If your Comparator says two different objects compare as 0, TreeMap treats them as one key — so puts overwrite and lookups can 'miss' keys, breaking the Map contract.

They return sub-portions of the TreeMap by key range: headMap = keys below a bound, tailMap = keys at/above a bound, subMap = keys between two bounds. The overloads with a boolean let you include or exclude the endpoints. The result is a live view, not a copy — changes go both ways.

A LinkedHashMap LRU is simple but not thread-safe, and even reads mutate it in access-order mode, so concurrent use needs full locking. For real systems pick a library like Caffeine that gives concurrent access, expiry, and size weighting.

Use TreeMap when you need keys in sorted order or range/nearest-key queries. Otherwise prefer HashMap for speed. For thread-safe sorted access use ConcurrentSkipListMap; for fixed sorted data, a sorted array with binary search can be faster and lighter.