6.4 The Map Interface, Sorting, Comparable, and Comparator

6.4 The Map Interface, Sorting, Comparable, and Comparator

Mapping keys to values and establishing precise sort orders are foundational operations in enterprise Java development. The Map<K, V> interface provides key-value associations without extending Collection. On the 1Z0-829 exam, questions frequently test the inner workings of hash bucket resolution, the strict equals() and hashCode() contract, modern lambda-enabled Map methods (merge, computeIfAbsent), and complex multi-tiered sorting using Comparable and Comparator combinators.

---

The Map Interface and Implementations

A Map<K, V> maps unique keys to values, prohibiting duplicate keys. Its primary implementations offer distinct performance and ordering trade-offs:

1. HashMap

• Internal Structure: An array of hash buckets. Collisions are stored in linked lists; when a bucket exceeds 8 entries and total table capacity reaches at least 64, the bucket transforms into a balanced red-black tree (TreeNode) to guarantee $O(\log n)$ worst-case lookup rather than $O(n)$.
• Null Policy: Allows one null key and multiple null values.
• Ordering: No ordering guarantees; bucket order shifts when resizing.

2. LinkedHashMap

• Internal Structure: Extends HashMap while maintaining a doubly-linked list through all entries.
• Ordering Modes: Defaults to insertion order. Can be configured via its constructor (new LinkedHashMap<>(16, 0.75f, true)) to track access order, making it an ideal foundation for Least-Recently-Used (LRU) caches when combined with removeEldestEntry().

3. TreeMap

• Internal Structure: A Red-Black tree implementing NavigableMap<K, V>.
• Ordering: Keys are sorted according to natural ordering (Comparable) or an explicit Comparator.
• Null Policy: Prohibits null keys when using natural ordering (throws NullPointerException). Allows null values.
• Performance: $O(\log n)$ for get, put, remove, and containsKey.

NavigableMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(10, "Ten");
treeMap.put(20, "Twenty");
treeMap.put(30, "Thirty");

System.out.println(treeMap.lowerKey(20));   // 10 (greatest key < 20)
System.out.println(treeMap.floorKey(20));   // 20 (greatest key <= 20)
System.out.println(treeMap.ceilingKey(25)); // 30 (least key >= 25)
System.out.println(treeMap.higherKey(20));  // 30 (least key > 20)

---

The equals() and hashCode() Contract

Hash-based collections (HashMap, HashSet) use an object's hashCode() to determine its bucket index, and equals() to resolve bucket collisions. The contract mandates:

1. If a.equals(b) is true, then a.hashCode() == b.hashCode() must be true.
2. If a.hashCode() == b.hashCode(), a.equals(b) is not required to be true (hash collision).
3. If a.equals(b) is false, hash codes are not required to be distinct, though unique hash codes optimize performance.

The Mutable Key Hazard

If an object used as a map key is mutated such that its hashCode() changes, the entry becomes permanently lost:

class AccountKey {
    int accountId;
    AccountKey(int id) { this.accountId = id; }
    public boolean equals(Object o) { 
        return o instanceof AccountKey k && this.accountId == k.accountId; 
    }
    public int hashCode() { return accountId; }
}

Map<AccountKey, String> map = new HashMap<>();
AccountKey key = new AccountKey(101);
map.put(key, "Active");

// Mutate key field after insertion
key.accountId = 999; 

// Lookup computes hashCode 999, searching the wrong bucket!
System.out.println(map.get(key)); // Prints null! Entry is stranded.

---

Modern Functional Map Methods (Java 8+)

Java 8 introduced powerful methods on Map that accept lambdas for atomic modifications:

1. getOrDefault(key, defaultValue)

Returns the value mapped to key, or defaultValue if the key is not found or is explicitly mapped to null.

2. putIfAbsent(key, value)

Inserts value only if key is absent or currently mapped to null. Returns the existing value, or null if the new value was placed.

3. computeIfAbsent(key, k -> compute(k))

If key is absent or mapped to null, evaluates the mapping function. If the function returns non-null, inserts the result and returns it. If the function returns null, no entry is created.

4. computeIfPresent(key, (k, v) -> compute(k, v))

If key is present and mapped to a non-null value, executes the remapping function with (key, oldValue).

• If the function returns non-null, updates the entry.
• CRITICAL TRAP: If the function returns null, the entry is removed from the map!

5. compute(key, (k, v) -> compute(k, v))

Executes the remapping function regardless of whether the key exists (v will be null if absent).

• If the function returns non-null, inserts or updates the entry.
• If the function returns null, removes the entry (or leaves it absent).

6. merge(key, value, (oldVal, newVal) -> remap)

The merge method has the most surprising rules of the group. It takes a key, a non-null value, and a BiFunction remapping function:

• If key is absent or mapped to null: associates key directly with value. The remapping function is never invoked!
• If key is present with non-null oldVal: invokes remappingFunction.apply(oldVal, value).
  • If the function returns non-null, updates the key with the returned result.
  • CRITICAL TRAP: If the function returns null, the key is removed from the map!
• If the value argument passed to merge is null, it throws NullPointerException immediately.

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 50);

// 1. Existing key: invokes lambda (90 + 10 = 100)
scores.merge("Alice", 10, (oldVal, newVal) -> oldVal + newVal); // Alice=100

// 2. Absent key: assigns 75 directly without calling lambda
scores.merge("Carol", 75, (oldVal, newVal) -> oldVal + newVal); // Carol=75

// 3. Lambda returns null: REMOVES key from map!
scores.merge("Bob", 50, (oldVal, newVal) -> null); // Bob is removed!

System.out.println(scores); // Prints {Alice=100, Carol=75}

---

Sorting with Comparable<T> vs. Comparator<T>

Java provides two interfaces to define order:

The compareTo Contract and TreeSet/TreeMap

The compareTo(T o) method returns:

• A negative integer if this < o
• Zero if the two objects are equal in sort order (ideally only when this.equals(o) is also true)
• A positive integer if this > o