6.3 Kotlin集合类型之Map、MutableMap

Kotlin集合类型之Map、MutableMap

• • Map
  • • • 声明和创建Map集合
      • Map常用函数
  • Kotlin MutableMap
  • • • 声明和创建MutableMap
      • MutableMap常用函数
      • HashMap、LinkedHashMap、TreeMap

Map是一个接口和通用的元素集合。 Map以键和值对的形式保存数据。 映射的键是唯一的，每个键只保留一个值。 键和值可以是不同类型。 也被分为可变的和不可变的，即Map与MutableMap.

Map

它是不可变的，它的大小固定，方法支持只读访问。要使用Map接口，需要使用mapOf()或mapOf <k，v>()函数声明。

声明和创建Map集合

声明和创建Map有很多方式，下面一一介绍：
mapOf()声明一个空的map： 返回一个只读的空的map
源码:

/**
 * Returns an empty read-only map.
 *
 * The returned map is serializable (JVM).
 * @sample samples.collections.Maps.Instantiation.emptyReadOnlyMap
 */
@kotlin.internal.InlineOnly
public inline fun <K, V> mapOf(): Map<K, V> = emptyMap()

声明：

val first = mapOf<String, String>()

mapOf()声明非空Map： 返回不可变的Map集合。接收多个key-value对，这些key-value对将作为Map的元素。
源码：

/**
 * Returns a new read-only map with the specified contents, given as a list of pairs
 * where the first value is the key and the second is the value.
 *
 * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.
 *
 * Entries of the map are iterated in the order they were specified.
 *
 * The returned map is serializable (JVM).
 *
 * @sample samples.collections.Maps.Instantiation.mapFromPairs
 */
public fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V> =
    if (pairs.size > 0) pairs.toMap(LinkedHashMap(mapCapacity(pairs.size))) else emptyMap()

声明：

val name = mapOf<String, String>("name" to "alfred", "sex" to "man", "age" to "27")

Map常用函数

函数

描述

getValue(key)

它返回给定键的值，如果映射中没有这样的键，则抛出异常。

getOrDefault(key,defaultValue)

获取指定key值的value，没有值时返回默认值

contains(key)、containsKey(key)

它检查在Map中是否包含给定的键。

minus(key)

返回去除该 key-value的map

plus(pair)

向map中添加key - value

例：

fun main(args: Array<String>) {
    val name = mapOf<String, String>("name" to "alfred", "sex" to "man", "age" to "27")
    println(name["name"])
    println(name.get("name"))
    println(name.getValue("name"))
    println(name.getOrDefault("weight","70kg"))

    println(name.contains("name"))
    println(name.containsKey("name"))

    println(name.minus("age"))

    println(name.plus("height" to "180cm"))
}

结果：

alfred
alfred
alfred
70kg
true
true
{name=alfred, sex=man}
{name=alfred, sex=man, age=27, height=180cm}

Kotlin MutableMap

MutableMap是集合框架的接口，它以键和值对的形式保存对象。 通过使用相应的键来检索MutableMap接口的值。 键和值可以是不同类型的对，它是可变的。

声明和创建MutableMap

mutableMapOf()声明空的可变map: 该函数返回空的可变的MutableMap集合。
源码：

/**
 * Returns an empty new [MutableMap].
 *
 * The returned map preserves the entry iteration order.
 * @sample samples.collections.Maps.Instantiation.emptyMutableMap
 */
@SinceKotlin("1.1")
@kotlin.internal.InlineOnly
public inline fun <K, V> mutableMapOf(): MutableMap<K, V> = LinkedHashMap()

声明：

val first = mutableMapOf<String, String>()

mutableMapOf()声明非空的可变map: 该函数返回空的可变的MutableMap集合，接收多个key-value对，这些key-value对将作为Map的元素。
源码：

/**
 * Returns a new [MutableMap] with the specified contents, given as a list of pairs
 * where the first component is the key and the second is the value.
 *
 * If multiple pairs have the same key, the resulting map will contain the value from the last of those pairs.
 *
 * Entries of the map are iterated in the order they were specified.
 *
 * @sample samples.collections.Maps.Instantiation.mutableMapFromPairs
 * @sample samples.collections.Maps.Instantiation.emptyMutableMap
 */
public fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V> =
    LinkedHashMap<K, V>(mapCapacity(pairs.size)).apply { putAll(pairs) }

声明：

    val name = mutableMapOf<String, String>("name" to "alfred", "sex" to "man", "age" to "27")

MutableMap常用函数

函数

描述

put(key,value)、MutableMap[key]=value

放入key-value对。如果原来已有key，value将被覆盖

putAll(Map)

向原map中添加整个map

remove(key)

删除指定key以及对应value

remove(key, value)

存在键和值实体时，才会删除它们

clear()

删除所有元素

contains(key)、containsKey(key)

检查是否包含给定键，如果map包含指定的键，则返回true

containsValue(value)

如果包含给定值的一个或多个键，则返回true

count()

它返回key-value对的总数

get(key)

返回与键对应的值，如果找不到指定键，则返回null

getOrDefault(key, defaultValue)

返回带有相应指定键的值，如果没有key对应的value，则返回默认值

getValue(key)

返回与给定键对应的值，如果找不到键，则抛出异常

请看下面部分实例：

    val persion = mutableMapOf("name" to "alfred")
    val persion2 = mutableMapOf("sex" to "man", "age" to "27")
    persion.put("身高", "180cm")
    println(persion)

    persion["体重"] = "70kg"
    println(persion)

    persion.putAll(persion2)
    println(persion)

    persion.remove("身高")
    println(persion)

    persion.remove("体重","70kg")
    println(persion)

结果：

{name=alfred, 身高=180cm}
{name=alfred, 身高=180cm, 体重=70kg}
{name=alfred, 身高=180cm, 体重=70kg, sex=man, age=27}
{name=alfred, 体重=70kg, sex=man, age=27}
{name=alfred, sex=man, age=27}

HashMap、LinkedHashMap、TreeMap

声明方式如下：
hashMapOf()： 该函数返回可变的HashMap集合。该函数可接受0个或多个key-value对，这些key-value对将作为Map的元素。
linkedMapOf()： 该函数返回可变的LinkedHashMap集合。该函数可接受0个或多个key-value对，这些key-value对将作为Map的元素。
sortedMapOf()： 该函数返回可变的TreeMap集合。该函数可接受0个或多个key-value对，这些key-value对将作为Map的元素。

可自行查看源码并研究，这儿不再讲述，声明实例如下：

fun main(args: Array<String>) {
    val hash = hashMapOf<String, String>("name" to "alfred")
    val linkedMap = linkedMapOf<String, String>("age" to "27")
    val treeMap = sortedMapOf("sex" to "man")

    println(hash)
    println(linkedMap)
    println(treeMap)
}

结果：

{name=alfred}
{age=27}
{sex=man}