如果我们从数据结构的本质上来看，其实List就是Key是Int类型下标的特殊的Map。而Set也是Key为Int，但是Value值不能重复的特殊Map。

    Kotlin中的Map与List、Set一样，Map也分为只读Map和可变的MutableMap。

    Map没有继承于Collection接口。其类图结构如下：

    在接口interface Map<K, out V>中，K是键值的类型，V是对应的映射值的类型。这里的out V表示类型为V或V的子类。这是泛型的相关知识，我们将在下一章节中介绍。

    其中，Entry<out K, out V>中保存的是Map的键值对。

    跟Java相比不同的是，在Kotlin中的Map区分了只读的Map和可编辑的Map（MutableMap、HashMap、LinkedHashMap）。

    Kotlin没有自己重新去实现一套集合类，而是在Java的集合类基础上做了一些扩展。

    我们知道在Java中，根据内部数据结构的不同，Map 接口通常有多种实现类。

    其中常用的有：

    • HashMap

    HashMap是基于哈希表（hash table）的 Map 接口的实现，以key-value的形式存在。在HashMap中，key-value是一个整体，系统会根据hash算法来来计算key-value的存储位置，我们可以通过key快速地存取value。它允许使用 null 值和 null 键。

    另外，HashMap中元素的顺序，随着时间的推移会发生变化。

    • TreeMap

    使用红黑二叉树（red-black tree）的 Map 接口的实现。

    • LinkedHashMap

    还有继承了HashMap，并使用链表实现的LinkedHashMap。LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录是先插入的记录。简单说，LinkedHashMap是有序的，它使用链表维护内部次序。

    我们在使用Kotlin创建Map的时候，实际上大部分都是调用Java的Map的方法。

    下面我们就来介绍Map的创建以及基本操作函数。

    mapOf()

    创建一个只读空Map。

    我们还可以用另外一个函数创建空Map：

    1. >>> val map2 = emptyMap<String, Int>()
    2. >>> map2.size
    3. 0
    4. >>> map2.isEmpty()
    5. true

    空Map都是相等的：

    1. >>> map2==map1
    2. true

    这个空Map是只读的，其属性和函数返回都是预定义好的。其代码如下：

    1. private object EmptyMap : Map<Any?, Nothing>, Serializable {
    2.     private const val serialVersionUID: Long = 8246714829545688274
    4.     override fun equals(other: Any?): Boolean = other is Map<*,*> && other.isEmpty()
    5.     override fun hashCode(): Int = 0
    6.     override fun toString(): String = "{}"
    8.     override val size: Int get() = 0
    9.     override fun isEmpty(): Boolean = true
    11.     override fun containsKey(key: Any?): Boolean = false
    12.     override fun containsValue(value: Nothing): Boolean = false
    13.     override fun get(key: Any?): Nothing? = null
    14.     override val entries: Set<Map.Entry<Any?, Nothing>> get() = EmptySet
    15.     override val keys: Set<Any?> get() = EmptySet
    16.     override val values: Collection<Nothing> get() = EmptyList
    18.     private fun readResolve(): Any = EmptyMap
    19. }

    mapOf(pair: Pair<K, V>): Map<K, V>

    使用二元组Pair创建一个只读Map。

    1. >>> val map = mapOf(1 to "x", 2 to "y", 3 to "z")
    2. >>> map
    3. {1=x, 2=y, 3=z}
    4. >>> map.get(1)
    5. x
    6. >>> map.get(3)
    7. z
    8. >>> map.size
    9. 3
    10. >>> map.entries
    11. [1=x, 2=y, 3=z]

    这个创建函数内部是调用的LinkedHashMap构造函数，其相关代码如下：

    1. pairs.toMap(LinkedHashMap(mapCapacity(pairs.size)))

    如果我们想编辑这个Map， 编译器会直接报错

    1. >>> map[1]="a"
    2. error: unresolved reference. None of the following candidates is applicable because of receiver type mismatch: 
    3. @InlineOnly public operator inline fun <K, V> MutableMap<Int, String>.set(key: Int, value: String): Unit defined in kotlin.collections
    4. @InlineOnly public operator inline fun kotlin.text.StringBuilder /* = java.lang.StringBuilder */.set(index: Int, value: Char): Unit defined in kotlin.text
    5. map[1]="a"
    6. ^
    7. error: no set method providing array access
    8. map[1]="a"
    9.    ^

    因为在不可变（Immutable）Map中，根本就没有提供set函数。

    mutableMapOf()

    创建一个空的可变的Map。

    1. >>> val map = mutableMapOf<Int, Any?>()
    2. >>> map.isEmpty()
    3. true
    4. >>> map[1] = "x"
    5. >>> map[2] = 1
    6. >>> map
    7. {1=x, 2=1}

    mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

    创建一个可编辑的MutableMap对象。

    1. >>> val map = mutableMapOf(1 to "x", 2 to "y", 3 to "z")
    2. >>> map
    3. {1=x, 2=y, 3=z}
    4. >>> map[1]="a"
    5. >>> map
    6. {1=a, 2=y, 3=z}

    另外，如果Map中有重复的key键，后面的会直接覆盖掉前面的：

    1. >>> map
    2. {1=z, 2=y}

    后面的1 to "z"直接把前面的1 to "x"覆盖掉了。

    hashMapOf(): HashMap<K, V>

    创建HashMap对象。Kotlin直接使用的是Java的HashMap。

    1. >>> val map: HashMap<Int, String> = hashMapOf(1 to "x", 2 to "y", 3 to "z")
    2. >>> map
    3. {1=x, 2=y, 3=z}

    linkedMapOf(): LinkedHashMap<K, V>

    创建空对象LinkedHashMap。直接使用的是Java中的LinkedHashMap。

    1. >>> val map: LinkedHashMap<Int, String> = linkedMapOf()
    2. >>> map
    3. {}
    4. >>> map[1]="x"
    5. >>> map

    linkedMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>

    创建带二元组Pair元素的LinkedHashMap对象。直接使用的是Java中的LinkedHashMap。

    1. >>> val map: LinkedHashMap<Int, String> = linkedMapOf(1 to "x", 2 to "y", 3 to "z")
    2. >>> map
    3. {1=x, 2=y, 3=z}
    4. >>> map[1]="a"
    5. >>> map
    6. {1=a, 2=y, 3=z}

    sortedMapOf(vararg pairs: Pair<K, V>): SortedMap<K, V>

    创建一个根据Key升序排序好的TreeMap。对应的是使用Java中的SortedMap。

    1. >>> val map = sortedMapOf(Pair("c", 3), Pair("b", 2), Pair("d", 1))
    2. >>> map
    3. {b=2, c=3, d=1}

    entries属性

    我们可以直接访问entries属性

    1. val entries: Set<Entry<K, V>>

    获取该Map中的所有键/值对的Set。这个Entry类型定义如下：

    1. public interface Entry<out K, out V> {
    2.     public val key: K
    3.     public val value: V
    4. }

    代码示例

    1. >>> val map = mapOf("x" to 1, "y" to 2, "z" to 3)
    2. >>> map
    3. {x=1, y=2, z=3}
    4. >>> map.entries
    5. [x=1, y=2, z=3]

    这样，我们就可以遍历这个Entry的Set了：

    1. >>> map.entries.forEach({println("key="+ it.key + " value=" + it.value)})
    2. key=x value=1
    3. key=y value=2
    4. key=z value=3

    keys属性

    访问keys属性：

    获取Map中的所有键的Set。

    1. >>> map.keys
    2. [x, y, z]

    values属性

    访问val values: Collection<V>获取Map中的所有值的Collection。这个值的集合可能包含重复值。

    1. >>> map.values
    2. [1, 2, 3]

    size属性

    访问val size: Int获取map键/值对的数目。

    1. >>> map.size
    2. 3

    get(key: K)

    我们使用get函数来通过key来获取value的值。

    1. operator fun get(key: K): V?

    对应的操作符是[]：

    1. >>> map["x"]
    2. 1
    3. >>> map.get("x")
    4. 1

    如果这个key不在Map中，就返回null。

    1. >>> map["k"]
    2. null

    如果不想返回null，可以使用getOrDefault函数

    1. getOrDefault(key: K, defaultValue: @UnsafeVariance V): V

    当为null时，不返回null，而是返回设置的一个默认值：

    1. >>> map.getOrDefault("k",0)
    2. 0

    这个默认值的类型，要和V对应。类型不匹配会报错：

    1. >>> map.getOrDefault("k","a")
    2. error: type mismatch: inferred type is String but Int was expected
    3. map.getOrDefault("k","a")
    4.                      ^

    containsKey(key: K): Boolean

    是否包含该key。

    1. >>> val map = mapOf("x" to 1, "y" to 2, "z" to 3)
    2. >>> map.containsKey("x")
    3. true
    4. >>> map.containsKey("j")
    5. false

    containsValue(value: V): Boolean

    是否包含该value。

    1. >>> val map = mapOf("x" to 1, "y" to 2, "z" to 3)
    2. >>> map.containsValue(2)
    3. true
    4. >>> map.containsValue(20)
    5. false

    component1() component2()

    Map.Entry<K, V>的操作符函数，分别用来直接访问key和value。

    1. >>> val map = mapOf("x" to 1, "y" to 2, "z" to 3)
    2. >>> map.entries.forEach({println("key="+ it.component1() + " value=" + it.component2())})
    3. key=x value=1
    4. key=y value=2
    5. key=z value=3

    这两个函数的定义如下：

    1. @kotlin.internal.InlineOnly
    2. public inline operator fun <K, V> Map.Entry<K, V>.component1(): K = key
    4. @kotlin.internal.InlineOnly
    5. public inline operator fun <K, V> Map.Entry<K, V>.component2(): V = value

    Map.Entry<K, V>.toPair(): Pair<K, V>

    1. >>> map.entries
    2. [x=1, y=2, z=3]
    3. >>> map.entries.forEach({println(it.toPair())})
    4. (x, 1)
    5. (y, 2)
    6. (z, 3)

    getOrElse(key: K, defaultValue: () -> V): V

    通过key获取值，当没有值可以设置默认值。

    1. >>> val map = mutableMapOf<String, Int?>()
    2. >>> map.getOrElse("x", { 1 })
    3. 1
    4. >>> map["x"] = 3
    5. >>> map.getOrElse("x", { 1 })
    6. 3

    getValue(key: K): V

    当Map中不存在这个key，调用get函数，如果不想返回null，直接抛出异常，可调用此方法。

    1. val map = mutableMapOf<String, Int?>()
    2. >>> map.get("v")
    3. null
    4. >>> map.getValue("v")
    5. java.util.NoSuchElementException: Key v is missing in the map.
    6.     at kotlin.collections.MapsKt__MapWithDefaultKt.getOrImplicitDefaultNullable(MapWithDefault.kt:19)
    7.     at kotlin.collections.MapsKt__MapsKt.getValue(Maps.kt:252)

    getOrPut(key: K, defaultValue: () -> V): V

    如果不存在这个key，就添加这个key到Map中，对应的value是defaultValue。

    1. >>> val map = mutableMapOf<String, Int?>()
    2. >>> map.getOrPut("x", { 2 })
    3. 2
    4. >>> map
    5. {x=2}

    iterator(): Iterator<Map.Entry<K, V>>

    这个函数返回的是 entries.iterator()。这样我们就可以像下面这样使用for循环来遍历Map：

    mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>

    把Map的Key设置为通过转换函数transform映射之后的值。

    1. >>> val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> val mmap = map.mapKeys{it.key * 10}
    3. >>> mmap

    注意，这里的it是Map的Entry。 如果不巧，有任意两个key通过映射之后相等了，那么后面的key将会覆盖掉前面的key。

    1. >>> val mmap = map.mapKeys{it.key * it.key}
    2. >>> mmap
    3. {1=z, 4=b, 9=c}

    我们可以看出，被-1 to "z"覆盖掉了。

    mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>

    对应的这个函数是把Map的value设置为通过转换函数transform转换之后的新值。

    1. >>> val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> val mmap = map.mapValues({it.value + "$"})
    3. >>> mmap
    4. {1=a$, 2=b$, 3=c$, -1=z$}

    filterKeys(predicate: (K) -> Boolean): Map<K, V>

    返回过滤出满足key判断条件的元素组成的新Map。

    1. >>> val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map.filterKeys({it>0})
    3. {1=a, 2=b, 3=c}

    注意，这里的it元素是Key。

    filterValues(predicate: (V) -> Boolean): Map<K, V>

    返回过滤出满足value判断条件的元素组成的新Map。

    1. >>> val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map.filterValues({it>"b"})
    3. {3=c, -1=z}

    注意，这里的it元素是value。

    filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

    返回过滤出满足Entry判断条件的元素组成的新Map。

    1. >>> val map:Map<Int,String> = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map.filter({it.key>0 && it.value > "b"})
    3. {3=c}

    Iterable<Pair<K, V>>.toMap(destination: M): M

    把持有Pair的Iterable集合转换为Map。

    1. >>> val pairList = listOf(Pair(1,"a"),Pair(2,"b"),Pair(3,"c"))
    2. >>> pairList
    3. [(1, a), (2, b), (3, c)]
    4. >>> pairList.toMap()
    5. {1=a, 2=b, 3=c}

    Map<out K, V>.toMutableMap(): MutableMap<K, V>

    把一个只读的Map转换为可编辑的MutableMap。

    1. >>> val map = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map[1]="x"
    3. error: unresolved reference. None of the following candidates is applicable ...
    4. error: no set method providing array access
    5. map[1]="x"
    6.    ^
    8. >>> val mutableMap = map.toMutableMap()
    9. >>> mutableMap
    10. {1=a, 2=b, 3=c, -1=z}
    11. >>> mutableMap[1]="x"
    12. >>> mutableMap
    13. {1=x, 2=b, 3=c, -1=z}

    plus minus

    Map的加法运算符函数如下：

    1. operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>
    2. operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>
    3. operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>
    4. operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>
    5. operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>

    代码示例：

    1. >>> val map = mapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map+Pair(10,"g")
    3. {1=a, 2=b, 3=c, -1=z, 10=g}
    4. >>> map + listOf(Pair(9,"s"),Pair(10,"w"))
    5. {1=a, 2=b, 3=c, -1=z, 9=s, 10=w}
    6. >>> map + arrayOf(Pair(9,"s"),Pair(10,"w"))
    7. {1=a, 2=b, 3=c, -1=z, 9=s, 10=w}
    8. >>> map + sequenceOf(Pair(9,"s"),Pair(10,"w"))
    9. {1=a, 2=b, 3=c, -1=z, 9=s, 10=w}
    10. >>> map + mapOf(9 to "s", 10 to "w")
    11. {1=a, 2=b, 3=c, -1=z, 9=s, 10=w}

    加并赋值函数：

    1. inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>)
    2. inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>)
    3. inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)
    4. inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>)
    5. inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>)

    代码示例：

    1. >>> val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map+=Pair(10,"g")
    3. >>> map
    4. {1=a, 2=b, 3=c, -1=z, 10=g}
    5. >>> map += listOf(Pair(9,"s"),Pair(11,"w"))
    6. >>> map
    7. {1=a, 2=b, 3=c, -1=z, 10=g, 9=s, 11=w}
    8. >>> map += mapOf(20 to "qq", 30 to "tt")
    9. >>> map
    10. {1=a, 2=b, 3=c, -1=z, 10=g, 9=s, 11=w, 20=qq, 30=tt}

    减法跟加法类似。

    put(key: K, value: V): V?

    根据key设置元素的value。如果该key存在就更新value；不存在就添加，但是put的返回值是null。

    1. >>> val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map
    3. {1=a, 2=b, 3=c, -1=z}
    4. >>> map.put(10,"q")
    5. null
    6. >>> map
    7. {1=a, 2=b, 3=c, -1=z, 10=q}
    8. >>> map.put(1,"f")
    9. a
    10. >>> map
    11. {1=f, 2=b, 3=c, -1=z, 10=q}

    putAll(from: Map<out K, V>): Unit

    把一个Map全部添加到一个MutableMap中。

    1. >>> val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> val map2 = mapOf(99 to "aa", 100 to "bb")
    3. >>> map.putAll(map2)
    4. >>> map
    5. {1=a, 2=b, 3=c, -1=z, 99=aa, 100=bb}

    如果有key重复的，后面的值会覆盖掉前面的值：

    1. >>> map
    2. {1=a, 2=b, 3=c, -1=z, 99=aa, 100=bb}
    3. >>> map.putAll(mapOf(1 to "www",2 to "tttt"))
    4. >>> map
    5. {1=www, 2=tttt, 3=c, -1=z, 99=aa, 100=bb}

    MutableMap<out K, V>.remove(key: K): V?

    根据键值key来删除元素。

    1. >>> val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map.remove(-1)
    3. z
    4. >>> map
    5. {1=a, 2=b, 3=c}
    6. >>> map.remove(100)
    7. null
    8. >>> map
    9. {1=a, 2=b, 3=c}

    MutableMap<K, V>.clear(): Unit

    清空MutableMap。

    1. >>> val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c", -1 to "z")
    2. >>> map
    3. {1=a, 2=b, 3=c, -1=z}
    4. >>> map.clear()
    5. >>> map
    6. {}

    本章小结

    集合类持有的是对象，而怎样的放入正确的对象类型则是我们写代码过程中需要注意的。下一章节中我们将学习泛型。