HashMaps — The Complete Visual Reference

val ro = mapOf("a" to 1) // Map (read-only) val mu = mutableMapOf("a" to 1) // MutableMap mu["b"] = 2 // OK // ro["b"] = 2 // compile error

// ── From pairs ── mapOf("a" to 1, "b" to 2) mutableMapOf("a" to 1) hashMapOf("a" to 1) // unordered HashMap<String, Int>(256) // pre-sized // ── From collections ── words.associateWith { it.length } // {hello=5, world=5} words.associateBy { it.first() } // {h=hello, w=world} (dup keys: last wins) words.associate { it to it.uppercase() } keys.zip(values).toMap() (1..5).associate { it to it * it } // ── DSL builder ── val m = buildMap { put("a", 1); put("b", 2) } // ── Conversions ── map.toMutableMap() // mutable copy map.toMap() // defensive copy map.toSortedMap() // → TreeMap map.toList() // List<Pair<K,V>>

// ── Access — O(1) avg ── map["key"] // V? (null if absent) map.getValue("key") // V (throws if absent) map.getOrDefault("x", 0) map.getOrElse("x") { compute() } // ── Membership ── "key" in map // O(1) avg map.containsKey("k") // O(1) avg map.containsValue(42) // ⚠ O(n) scan! map.size map.isEmpty() // ── Destructuring ── for ((name, score) in map) { println("$name: $score") }

// ── Insert / Update ── map["key"] = 42 // insert or overwrite map.put("key", 42) // returns prev value map.putAll(otherMap) // bulk insert map += "key" to 42 // ── Conditional insert ── map.putIfAbsent("k", 1) // only if absent // ★ MOST USEFUL — insert default if absent: map.getOrPut("k") { mutableListOf() } .add(item) // freq counting, grouping // ── Merge ── map.merge("k", 1) { old, new -> old + new } // ── Replace ── map.replace("k", 99) // only if key exists map.replace("k", 1, 99) // only if k→1

// ── Iteration ── map.forEach { (k, v) -> println("$k=$v") } map.keys map.values map.entries // ── Transform — returns NEW map ── map.mapValues { (_, v) -> v * 2 } map.mapKeys { (k, _) -> k.uppercase() } map.map { (k, v) -> "$k=$v" } // → List! // ── Filter ── map.filter { (_, v) -> v > 10 } map.filterKeys { it.startsWith("a") } map.filterValues { it != 0 } // ── Aggregate ── map.any { (_, v) -> v > 100 } map.count { (_, v) -> v > 0 } map.maxByOrNull { it.value } map.values.sum() map.values.average() // ── Remove ── map.remove("key") // returns removed V? map -= "key"; map.clear() map.entries.removeIf { (_, v) -> v < 0 }

// ── TreeMap — sorted by key, O(log n) ── val tm = sortedMapOf("c" to 3, "a" to 1) tm.firstKey() // "a" tm.lastKey() // "c" tm.higherKey("a") // "c" (strictly >) tm.lowerKey("c") // "a" (strictly <) tm.ceilingKey("b") // "c" (>=) tm.floorKey("b") // "a" (<=) tm.subMap("a", "c") // {a=1} (from incl, to excl) tm.headMap("c") // {a=1} (before key) tm.tailMap("a") // {a=1, c=3} (from key) map.toSortedMap() // convert any map // Custom comparator sortedMapOf(compareByDescending { it }, "a" to 1) // ── LinkedHashMap — insertion order ── val lhm = linkedMapOf("c" to 3, "a" to 1) lhm.keys // [c, a] — insertion order // Access-order mode (for LRU — see below)

// ── Fibonacci with memoization ── val cache = mutableMapOf<Int, Long>() fun fib(n: Int): Long = cache.getOrPut(n) { if (n <= 1) n.toLong() else fib(n - 1) + fib(n - 2) } // ── Multi-param key: use data class ── data class Key(val r: Int, val c: Int) val memo = mutableMapOf<Key, Int>() fun paths(r: Int, c: Int): Int = memo.getOrPut(Key(r, c)) { if (r == 0 || c == 0) 1 else paths(r-1, c) + paths(r, c-1) }

class LRUCache(private val cap: Int) : LinkedHashMap<Int, Int>(cap, 0.75f, true) { override fun removeEldestEntry( eldest: MutableMap.MutableEntry<Int, Int>? ) = size > cap } val c = LRUCache(3) c[1] = 10; c[2] = 20; c[3] = 30 c[1] // access → moves to end c[4] = 40 // evicts key 2 (eldest)

// WRONG: mutable object as key → lost entry! val key = mutableListOf(1, 2) map[key] = "value" key.add(3) // hashCode changes! map[key] // null — entry unreachable // RIGHT: use immutable keys (data class, String) // ⚠ read-only ≠ immutable val ro = mapOf("a" to 1) (ro as MutableMap)["b"] = 2 // compiles! 💥 // RIGHT: use .toMap() for defensive copy // ⚠ null ambiguity map["absent"] // null map["keyWithNullValue"] // also null! // RIGHT: map.containsKey("k") to distinguish // ⚠ ConcurrentModificationException for ((k, v) in map) map.remove(k) // 💥 // RIGHT: map.entries.removeIf { ... }