Kotlin 的Map分为 可变的 和 不可变的 两种

声明和创建 Map

• mapOf(): Map<K, V>
  该函数返回不可变的 Map 集合（Kotlin 1.1 返回的是LinkedHashMap）

• mutableMapOf(): MutableMap<K, V>
  该函数返回可变的 MutableMap 集合（Kotlin 1.1 返回的是LinkedHashMap）

• hashMapOf(): HashMap<K, V>
  该函数返回可变的 HashMap 集合

• linkedMapOf(): LinkedHashMap<K, V>
  该函数返回可变的 LinkedHashMap 集合

• sortedMapOf(): SortedMap<K, V>
  该函数返回可变的 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
  如果所有的元素都满足给定的条件，则返回 true

• map.any { ... }: Boolean
  如果至少有一个元素满足给定的条件，则返回 true

• (key in map): Boolean / (key !in map): Boolean
  由于有 contains() 方法，所以可以使用 in 、!in

• map.filter { ... }: Map<K, V>
  对 Map 集合中的元素进行过滤

• map.map { ... }: List<R>
  将 Map 集合中的元素映射成一个新的 List 集合

• map.maxBy { ... }: Map.Entry<K, V>? / map.minBy { ... }: Map.Entry<K, V>?
  获取 Map 集合中的最大/最小元素

• (map + bMap): Map<K, V> / (map - bMap): Map<K, V>
  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 遍历，遍历的是 Entry

• for (key in map.keys) { ... }
  遍历 key，再通过 key 获取 value

• for ((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<out K, V>): 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