Optimize keySet() and values() to avoid unnecessary entrySet() rebuild

values() now iterates buckets directly, skipping expensive reconstructKey()
and SimpleEntry allocation entirely. keySet() iterates buckets directly,
avoiding SimpleEntry wrapper allocation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jdereg

changelog.md

@@ -46,6 +46,9 @@
   * Added `spread(h) = h ^ (h >>> 16)` at all bucket selection points (same technique as `ConcurrentHashMap`)
   * When the table is small, only low-order bits select the bucket; spreading mixes in higher bits to reduce collisions
   * Applied at all 7 bucket index computation sites; stored hashes are unchanged
+* **PERFORMANCE**: `MultiKeyMap` - `keySet()` and `values()` no longer rebuild full `entrySet()`
+  * `values()` now iterates buckets directly, skipping all key reconstruction (`reconstructKey()`) and `SimpleEntry` allocation
+  * `keySet()` now iterates buckets directly, skipping `SimpleEntry` wrapper allocation
 
 #### 4.90.0 2026-02-02
 * **BUG FIX**: `DeepEquals` - URL comparison now uses string representation instead of `URL.equals()`

src/main/java/com/cedarsoftware/util/MultiKeyMap.java

@@ -3563,8 +3563,32 @@ public boolean containsValue(Object value) {
      */
     public Set<Object> keySet() {
         Set<Object> set = new HashSet<>();
-        for (Map.Entry<Object, V> e : entrySet()) {
-            set.add(e.getKey());
+        final AtomicReferenceArray<MultiKey<V>[]> snapshot = buckets;
+        final int len = snapshot.length();
+        for (int bucketIdx = 0; bucketIdx < len; bucketIdx++) {
+            MultiKey<V>[] chain = snapshot.get(bucketIdx);
+            if (chain != null) {
+                for (MultiKey<V> e : chain) {
+                    Object keys = e.keys;
+                    Object k;
+                    if (keys == null || keys == NULL_SENTINEL) {
+                        k = null;
+                    } else if (keys instanceof Object[]) {
+                        Object[] keysArray = (Object[]) keys;
+                        k = keysArray.length == 1 ? (keysArray[0] == NULL_SENTINEL ? null : keysArray[0]) : reconstructKey(keysArray);
+                    } else if (keys instanceof Collection) {
+                        if (collectionKeyMode == CollectionKeyMode.COLLECTIONS_NOT_EXPANDED) {
+                            k = keys;
+                        } else {
+                            Object[] keysArray = ((Collection<?>) keys).toArray();
+                            k = reconstructKey(keysArray);
+                        }
+                    } else {
+                        k = keys;
+                    }
+                    set.add(k);
+                }
+            }
         }
         return set;
     }
@@ -3580,8 +3604,15 @@ public Set<Object> keySet() {
      */
     public Collection<V> values() {
         List<V> vals = new ArrayList<>();
-        for (Map.Entry<Object, V> e : entrySet()) {
-            vals.add(e.getValue());
+        final AtomicReferenceArray<MultiKey<V>[]> snapshot = buckets;
+        final int len = snapshot.length();
+        for (int bucketIdx = 0; bucketIdx < len; bucketIdx++) {
+            MultiKey<V>[] chain = snapshot.get(bucketIdx);
+            if (chain != null) {
+                for (MultiKey<V> e : chain) {
+                    vals.add(e.value);
+                }
+            }
         }
         return vals;
     }