Kotlin Map 集合 #

// 使用 mapOf
val map = mapOf("a" to 1, "b" to 2, "c" to 3)

// 空映射
val empty = emptyMap<String, Int>()

// 使用 LinkedHashMap（保持插入顺序）
val linked = linkedMapOf("a" to 1, "b" to 2)

// 使用 TreeMap（按键排序）
val sorted = sortedMapOf("c" to 3, "a" to 1, "b" to 2)

// 使用 HashMap
val hash = hashMapOf("a" to 1, "b" to 2)

// 使用 mutableMapOf
val mutable = mutableMapOf("a" to 1, "b" to 2)

// 使用 hashMapOf
val hash = hashMapOf("a" to 1, "b" to 2)

// 使用 linkedMapOf
val linked = linkedMapOf("a" to 1, "b" to 2)

val map = mapOf(
    Pair("a", 1),
    Pair("b", 2),
    "c" to 3
)

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

map["a"]              // 1
map.get("a")          // 1
map.getValue("a")     // 1
map.getOrDefault("d", 0)  // 0
map.getOrElse("d") { 0 }  // 0

val map = mapOf("a" to 1, "b" to 2)

map["c"]              // null
map.getValue("c")     // 抛出 NoSuchElementException
map.getOrDefault("c", 0)  // 0

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

map.keys              // [a, b, c]
map.values            // [1, 2, 3]
map.entries           // [a=1, b=2, c=3]

val map = mutableMapOf("a" to 1)

map["b"] = 2
map.put("c", 3)
// {a=1, b=2, c=3}

val map = mutableMapOf("a" to 1)

map.putAll(mapOf("b" to 2, "c" to 3))
// {a=1, b=2, c=3}

val map = mutableMapOf("a" to 1)

map.putIfAbsent("a", 10)  // 返回 1，不添加
map.putIfAbsent("b", 2)   // 返回 null，添加
// {a=1, b=2}

val map = mapOf("a" to 1, "b" to 2)

val newMap = map + ("c" to 3)
val newMap2 = map + mapOf("c" to 3, "d" to 4)

val map = mutableMapOf("a" to 1, "b" to 2, "c" to 3)

map.remove("a")       // 返回 1
map.remove("d")       // 返回 null
// {b=2, c=3}

val map = mutableMapOf("a" to 1, "b" to 2)

map.remove("a", 1)    // true，删除成功
map.remove("b", 10)   // false，值不匹配

val map = mutableMapOf("a" to 1, "b" to 2, "c" to 3)

map.entries.removeIf { it.value > 2 }
// {a=1, b=2}

val map = mutableMapOf("a" to 1, "b" to 2)

map.clear()
// {}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

val newMap = map - "a"
val newMap2 = map - listOf("a", "b")

val map = mutableMapOf("a" to 1, "b" to 2)

map["a"] = 10
// {a=10, b=2}

val map = mutableMapOf("a" to 1, "b" to 2)

map.compute("a") { _, value -> value?.times(2) }
// {a=2, b=2}

map.computeIfAbsent("c") { 3 }
// {a=2, b=2, c=3}

map.computeIfPresent("a") { _, value -> value + 1 }
// {a=3, b=2, c=3}

val map = mutableMapOf("a" to 1, "b" to 2)

map.merge("a", 10) { old, new -> old + new }
// {a=11, b=2}

map.merge("c", 3) { old, new -> old + new }
// {a=11, b=2, c=3}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

for ((key, value) in map) {
    println("$key -> $value")
}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

map.forEach { (key, value) ->
    println("$key -> $value")
}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

for (key in map.keys) {
    println("$key -> ${map[key]}")
}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

for (entry in map.entries) {
    println("${entry.key} -> ${entry.value}")
}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

map.containsKey("a")    // true
"a" in map              // true

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

map.containsValue(2)    // true
map.values.contains(2)  // true

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

map.filterKeys { it == "a" }      // {a=1}
map.filterValues { it > 1 }       // {b=2, c=3}
map.filter { (_, v) -> v > 1 }    // {b=2, c=3}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

val newKeys = map.mapKeys { it.key.uppercase() }
// {A=1, B=2, C=3}

val newValues = map.mapValues { it.value * 2 }
// {a=2, b=4, c=6}

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

val list = map.toList()  // [(a, 1), (b, 2), (c, 3)]
val keys = map.keys.toList()  // [a, b, c]
val values = map.values.toList()  // [1, 2, 3]

fun wordCount(text: String): Map<String, Int> {
    return text.split(Regex("\\s+"))
        .groupingBy { it.lowercase() }
        .eachCount()
}

val text = "Hello World Hello Kotlin"
val counts = wordCount(text)
// {hello=2, world=1, kotlin=1}

data class Person(val name: String, val department: String)

val people = listOf(
    Person("Alice", "Engineering"),
    Person("Bob", "Marketing"),
    Person("Charlie", "Engineering")
)

val byDepartment = people.groupBy { it.department }
// {Engineering=[Alice, Charlie], Marketing=[Bob]}

class Cache<K, V>(private val maxSize: Int) {
    private val map = linkedMapOf<K, V>()
    
    fun get(key: K): V? = map[key]
    
    fun put(key: K, value: V) {
        if (map.size >= maxSize && !map.containsKey(key)) {
            map.remove(map.keys.first())
        }
        map[key] = value
    }
    
    fun remove(key: K) = map.remove(key)
    
    fun clear() = map.clear()
}