4.Kotlin 集合 Map 所有方法

Kotlin Map 所有方法（按功能分类）

一、基础属性与判断

方法/属性	说明	示例
size: Int	键值对数量	val map = mapOf(1 to "a", 2 to "b") map.size // 2
isEmpty(): Boolean	判断是否为空映射	mapOf<Int, String>().isEmpty() // true
isNotEmpty(): Boolean	判断是否为非空映射	mapOf(1 to "a").isNotEmpty() // true

二、元素访问与检查

方法	说明	示例
containsKey(key: K): Boolean	判断是否包含指定键	val map = mapOf(1 to "a", 2 to "b") map.containsKey(1) // true
containsValue(value: V): Boolean	判断是否包含指定值	val map = mapOf(1 to "a", 2 to "b") map.containsValue("a") // true
get(key: K): V?	获取指定键对应的值（无则返回 null）	val map = mapOf(1 to "a", 2 to "b") map.get(1) // "a" map[1] // 简写形式
getOrDefault(key: K, defaultValue: V): V	获取值，无则返回默认值	val map = mapOf(1 to "a") map.getOrDefault(2, "default") // "default"
getValue(key: K): V	获取值（无则抛异常）	val map = mapOf(1 to "a") map.getValue(1) // "a"

三、键值集合获取

方法	说明	示例
keys: Set<K>	获取所有键的集合	val map = mapOf(1 to "a", 2 to "b") map.keys // [1, 2]
values: Collection<V>	获取所有值的集合	val map = mapOf(1 to "a", 2 to "b") map.values // ["a", "b"]
entries: Set<Map.Entry<K, V>>	获取所有键值对的集合	val map = mapOf(1 to "a", 2 to "b") map.entries // [1=a, 2=b]

四、迭代与遍历

方法	说明	示例
iterator(): Iterator<Map.Entry<K, V>>	返回键值对迭代器	val map = mapOf(1 to "a", 2 to "b") val it = map.iterator() while (it.hasNext()) println(it.next())
forEach(action: (Map.Entry<K, V>) -> Unit)	遍历所有键值对	val map = mapOf(1 to "a", 2 to "b") map.forEach { entry -> println("${entry.key}: ${entry.value}") }
forEach(action: (K, V) -> Unit)	遍历所有键值对（解构参数）	val map = mapOf(1 to "a", 2 to "b") map.forEach { k, v -> println("$k: $v") }

五、转换操作

方法	说明	示例
toMap(): Map<K, V>	转换为不可变映射（本身为Map时返回自身）	val map = mapOf(1 to "a") map.toMap() // {1=a}
toMutableMap(): MutableMap<K, V>	转换为可变映射	val map = mapOf(1 to "a") val mutableMap = map.toMutableMap() mutableMap[2] = "b" // {1=a, 2=b}
toList(): List<Pair<K, V>>	转换为键值对列表	val map = mapOf(1 to "a", 2 to "b") map.toList() // [(1, a), (2, b)]
plus(pair: Pair<K, V>): Map<K, V>	添加键值对并返回新映射（键重复会覆盖）	val map = mapOf(1 to "a") map.plus(2 to "b") // {1=a, 2=b} map.plus(1 to "c") // {1=c}
plus(pairs: Iterable<Pair<K, V>>): Map<K, V>	添加多个键值对并返回新映射	val map = mapOf(1 to "a") map.plus(listOf(2 to "b", 3 to "c")) // {1=a, 2=b, 3=c}
minus(key: K): Map<K, V>	移除指定键并返回新映射	val map = mapOf(1 to "a", 2 to "b") map.minus(1) // {2=b}
minus(keys: Iterable<K>): Map<K, V>	移除多个键并返回新映射	val map = mapOf(1 to "a", 2 to "b", 3 to "c") map.minus(listOf(1, 3)) // {2=b}
map(transform: (Map.Entry<K, V>) -> R): List<R>	转换为列表	val map = mapOf(1 to "a", 2 to "b") map.map { (k, v) -> "$k:$v" } // ["1:a", "2:b"]
mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>	转换键并返回新映射	val map = mapOf(1 to "a", 2 to "b") map.mapKeys { (k, _) -> "key$k" } // {"key1"=a, "key2"=b}
mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>	转换值并返回新映射	val map = mapOf(1 to "a", 2 to "b") map.mapValues { (_, v) -> v.uppercase() } // {1=A, 2=B}

六、过滤操作

方法	说明	示例
filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>	过滤键值对并返回新映射	val map = mapOf(1 to "a", 2 to "b", 3 to "c") map.filter { (k, _) -> k > 1 } // {2=b, 3=c}
filterKeys(predicate: (K) -> Boolean): Map<K, V>	按键过滤并返回新映射	val map = mapOf(1 to "a", 2 to "b", 3 to "c") map.filterKeys { it % 2 == 0 } // {2=b}
filterValues(predicate: (V) -> Boolean): Map<K, V>	按值过滤并返回新映射	val map = mapOf(1 to "a", 2 to "b", 3 to "c") map.filterValues { it > "a" } // {2=b, 3=c}
filterIsInstance<K, V>(): Map<K, V>	过滤指定类型的键值对	val map = mapOf(1 to "a", "b" to 2) map.filterIsInstance<Int, String>() // {1=a}

七、查找操作

方法	说明	示例
entries.first(): Map.Entry<K, V>	获取首个键值对（空映射抛异常）	mapOf(1 to "a", 2 to "b").entries.first() // 1=a
entries.firstOrNull(): Map.Entry<K, V>?	获取首个键值对（空映射返回 null）	mapOf<Int, String>().entries.firstOrNull() // null
entries.last(): Map.Entry<K, V>	获取最后一个键值对（空映射抛异常）	mapOf(1 to "a", 2 to "b").entries.last() // 2=b
entries.lastOrNull(): Map.Entry<K, V>?	获取最后一个键值对（空映射返回 null）	mapOf<Int, String>().entries.lastOrNull() // null
firstKey(): K	获取首个键（空映射抛异常）	mapOf(1 to "a", 2 to "b").firstKey() // 1
lastKey(): K	获取最后一个键（空映射抛异常）	mapOf(1 to "a", 2 to "b").lastKey() // 2
find(predicate: (Map.Entry<K, V>) -> Boolean): Map.Entry<K, V>?	查找首个满足条件的键值对	val map = mapOf(1 to "a", 2 to "b") map.find { (k, _) -> k > 1 } // 2=b

八、统计与判断

方法	说明	示例
count(): Int	键值对总数（等同于 size）	mapOf(1 to "a", 2 to "b").count() // 2
count(predicate: (Map.Entry<K, V>) -> Boolean): Int	满足条件的键值对数量	val map = mapOf(1 to "a", 2 to "b", 3 to "c") map.count { (k, _) -> k > 1 } // 2
all(predicate: (Map.Entry<K, V>) -> Boolean): Boolean	是否所有键值对满足条件	val map = mapOf(2 to "a", 4 to "b") map.all { (k, _) -> k % 2 == 0 } // true
any(predicate: (Map.Entry<K, V>) -> Boolean): Boolean	是否存在满足条件的键值对	val map = mapOf(1 to "a", 3 to "b", 4 to "c") map.any { (k, _) -> k % 2 == 0 } // true
none(predicate: (Map.Entry<K, V>) -> Boolean): Boolean	是否无键值对满足条件	val map = mapOf(1 to "a", 3 to "b") map.none { (k, _) -> k % 2 == 0 } // true

九、其他常用方法

方法	说明	示例
toString(): String	转换为字符串表示	mapOf(1 to "a", 2 to "b").toString() // "{1=a, 2=b}"
equals(other: Any?): Boolean	判断内容是否相等	mapOf(1 to "a").equals(mapOf(1 to "a")) // true
hashCode(): Int	计算哈希值	mapOf(1 to "a").hashCode() // 哈希值（因环境而异）
asSequence(): Sequence<Map.Entry<K, V>>	转换为序列（延迟计算）	val map = mapOf(1 to "a", 2 to "b") map.asSequence().filter { (k, _) -> k > 1 }.toMap() // {2=b}
onEach(action: (Map.Entry<K, V>) -> Unit): Map<K, V>	遍历键值对并返回自身	val map = mapOf(1 to "a", 2 to "b") map.onEach { println(it) } // {1=a, 2=b}
associate(transform: (Map.Entry<K, V>) -> Pair<R, S>): Map<R, S>	转换为新映射	val map = mapOf(1 to "a", 2 to "b") map.associate { (k, v) -> (k * 2) to v.uppercase() } // {2=A, 4=B}
associateBy(keySelector: (Map.Entry<K, V>) -> R): Map<R, Map.Entry<K, V>>	按键选择器创建新映射	val map = mapOf(1 to "a", 2 to "b") map.associateBy { (k, _) -> "key$k" } // {"key1"=1=a, "key2"=2=b}