kotlin将对象转换为map_Kotlin-Map

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

如果所有的元素都满足给定的条件，则返回 true

map.any { ... }: Boolean

如果至少有一个元素满足给定的条件，则返回 true

(key in map): Boolean / (key !in map): Boolean

由于有 contains() 方法，所以可以使用 in 、!in

map.filter { ... }: Map

对 Map 集合中的元素进行过滤

map.map { ... }: List

将 Map 集合中的元素映射成一个新的 List 集合

map.maxBy { ... }: Map.Entry? / map.minBy { ... }: Map.Entry?

获取 Map 集合中的最大/最小元素

(map + bMap): 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 遍历，遍历的是 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): 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