Kotlin 的Map分为 可变的 和 不可变的 两种
声明和创建 Map
mapOf(): Map
该函数返回不可变的 Map 集合（Kotlin 1.1 返回的是LinkedHashMap）mutableMapOf(): MutableMap
该函数返回可变的 MutableMap 集合（Kotlin 1.1 返回的是LinkedHashMap）hashMapOf(): HashMap
该函数返回可变的 HashMap 集合linkedMapOf(): LinkedHashMap
该函数返回可变的 LinkedHashMap 集合sortedMapOf(): SortedMap
该函数返回可变的 TreeMap 集合
Kotlin 中，初始化Map使用to来指定 key-value ：key to value
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
//map: {Java=86, Kotlin=92, Go=78}
println("map: $map")
//mapOf() 返回的对象的实际类型是：class java.util.LinkedHashMap
println("mapOf() 返回的对象的实际类型是：${map.javaClass}")
val mutableMap = mutableMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
//mutableMap: {Java=86, Kotlin=92, Go=78}
println("mutableMap: $mutableMap")
//mutableMapOf() 返回的对象的实际类型是：class java.util.LinkedHashMap
println("mutableMapOf() 返回的对象的实际类型是：${map.javaClass}")
val hashMap = hashMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
//hashMap: {Go=78, Java=86, Kotlin=92}
println("hashMap: $hashMap")
val linkedMap = linkedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
//linkedMap: {Java=86, Kotlin=92, Go=78}
println("linkedMap: $linkedMap")
val sortedMap = sortedMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
//sortedMap: {Go=78, Java=86, Kotlin=92}
println("sortedMap: $sortedMap")
注意：如果期望使用LinkedHashMap的话，最好使用linkedMapOf()，而不要使用mapOf()和mutableMapOf()，以免 Kotlin >底层修改逻辑导致程序出现bug
使用 Map 中的方法
map.all { ... }: Boolean
如果所有的元素都满足给定的条件，则返回 truemap.any { ... }: Boolean
如果至少有一个元素满足给定的条件，则返回 true(key in map): Boolean / (key !in map): Boolean
由于有 contains() 方法，所以可以使用 in 、!inmap.filter { ... }: Map
对 Map 集合中的元素进行过滤map.map { ... }: List
将 Map 集合中的元素映射成一个新的 List 集合map.maxBy { ... }: Map.Entry
获取 Map 集合中的最大/最小元素(map + bMap): Map
Map 集合相加/相减
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 76)
// map.all 如果所有的元素都满足给定的条件，则返回 true
println(map.all { it.key.length > 4 && it.value > 80 }) //false
// map.any 如果至少有一个元素满足给定的条件，则返回 true
println(map.any { it.key.length > 4 && it.value > 80 }) //true
// 由于有 contains() 方法，所以可以使用 in 、!in
println(map.contains("Java")) //true
println("Java" in map) //等价于上面
println(!map.contains("Go")) //false
println("Go" !in map) //等价于上面
// 对 Map 集合中的元素进行过滤，key 中包含 "o" 的元素
val filteredMap = map.filter { "o" in it.key }
println(filteredMap) //{Kotlin=92, Go=76}
// 将 Map 集合中的元素映射成一个新的 List 集合
val mappedList = map.map { "语言名称：${it.key} 价格：${it.value}" }
println(mappedList) //[语言名称：Java 价格：86, 语言名称：Kotlin 价格：92, 语言名称：Go 价格：76]
// 获取 Map 集合中的最大元素，根据 key
println(map.maxBy { it.key }) //Kotlin=92
// 获取 Map 集合中的最小元素，根据 key
println(map.minBy { it.key }) //Go=76
val bMap = mapOf("Swift" to 67, "JavaScript" to 80, "Kotlin" to 92)
// Map 集合相加，相当于并集（由于 Map 提供了 operate 修饰的 plus 方法，因此可以使用 "+" 运算符操作集合）
println(map + bMap) //{Java=86, Kotlin=92, Go=76, Swift=67, JavaScript=80}
// Map 集合相减，减去他们的公共元素（由于 Map 提供了 operate 修饰的 minus 方法，因此可以使用 "-" 运算符操作集合）
println(map - bMap) //{Java=86, Kotlin=92, Go=76}
Map 的遍历
for (entry in map.entries) { ... }
for-in 遍历，遍历的是 Entryfor (key in map.keys) { ... }
遍历 key，再通过 key 获取 valuefor ((key, value) in map) { ... }
for-in 遍历map.forEach { ... }
forEach Lambda 表达式遍历
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
// for-in 遍历，遍历的是 Entry
for (en in map.entries) {
println("${en.key}: ${en.value}")
}
// 遍历 key，再通过 key 获取 value
for (key in map.keys) {
println("$key: ${map[key]}")
}
// for-in 遍历
for ((key, value) in map) {
println("$key: $value")
}
// forEach Lambda 表达式遍历
map.forEach {
println("${it.key}: ${it.value}")
}
可变 Map 的添加、删除和替换
put(key: K, value: V): V?
放入 key-value 对，如果 key 已存在，则覆盖 value 值，return 先前的 value 值putAll(from: Map): Unit
批量放入多个 key-value 对remove(key: K): V?
移除 key-value 对，return 先前的 value 值clear(): Unit
清空 Map 中的所有元素
val mutableMap = mutableMapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
// 使用 [] 语法，放入值
mutableMap["Swift"] = 99
// 使用 put 方法，放入值
mutableMap.put("JavaScript", 10)
println(mutableMap) //{Java=86, Kotlin=92, Go=78, Swift=99, JavaScript=10}
println(mutableMap.size) //5
// 删除 key 为 "Java" 的键值对（key 存在）
mutableMap.remove("Java")
println(mutableMap) //{Kotlin=92, Go=78, Swift=99, JavaScript=10}
println(mutableMap.size) //4
// 删除 key 为 "TypeScript" 的键值对（key 不存在）
mutableMap.remove("TypeScript")
println(mutableMap) //{Kotlin=92, Go=78, Swift=99, JavaScript=10}
println(mutableMap.size) //4
// 清空 Map 中的所有元素
mutableMap.clear()
println(mutableMap) //{}
println(mutableMap.size) //0