Kotlin - 地图

---

Kotlin 映射是一组键/值对的集合，其中每个键都是唯一的，并且只能与一个值关联。不过，相同的值可以与多个键关联。我们可以将键和值声明为任何类型；没有任何限制。

Kotlin 映射可以是可变的 ( mutableMapOf ) 或只读的 ( mapOf )。

映射在其他编程语言中也称为字典或关联数组。

创建 Kotlin 地图

对于映射创建，请使用标准库函数mapOf()来创建只读映射，使用mutableMapOf()来创建可变映射。

可以通过将可变映射转换为 Map 来获取可变映射的只读视图。

例子

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    println(theMap)
    
    val theMutableMap = mutableSetOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    println(theMutableMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{one=1, two=2, three=3, four=4}
[(one, 1), (two, 2), (three, 3), (four, 4)]

使用HashMap创建Map

Kotlin 映射可以从 Java 的 HashMap 创建。

例子

fun main() {
    val theMap = HashMap<String, Int>()
    
    theMap["one"] = 1
    theMap["two"] = 2
    theMap["three"] = 3
    theMap["four"] = 4
    
    println(theMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{four=4, one=1, two=2, three=3}

创建地图时使用 Pair

我们可以使用Pair()方法来创建键/值对：

例子

fun main() {
    val theMap = mapOf(Pair("one", 1), Pair("two", 2), Pair("three", 3))
    println(theMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{one=1, two=2, three=3}

Kotlin 属性

Kotlin 映射具有获取映射的所有条目、键和值的属性。

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    
    println("Entries: " + theMap.entries)
    println("Keys:" + theMap.keys)
    println("Values:" + theMap.values)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

Entries: [one=1, two=2, three=3, four=4]
Keys:[one, two, three, four]
Values:[1, 2, 3, 4]

循环遍历 Kotlin 地图

有多种方法可以循环遍历 Kotlin 地图。让我们一一研究一下：

使用 toString() 函数

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    println(theMap.toString())
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{one=1, two=2, three=3, four=4}

使用迭代器

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    
    val itr = theMap.keys.iterator()
    while (itr.hasNext()) {
        val key = itr.next()
        val value = theMap[key]
        println("${key}=$value")
    }
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

one=1
two=2
three=3
four=4

使用 For 循环

fun main() {
   val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    
   for ((k, v) in theMap) {
      println("$k = $v")
   }
   
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

one = 1
two = 2
three = 3
four = 4

使用 forEach

fun main() {
   val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    
   theMap.forEach { 
      k, v -> println("Key = $k, Value = $v") 
   }
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

Key = one, Value = 1
Key = two, Value = 2
Key = three, Value = 3
Key = four, Value = 4

Kotlin 地图的大小

我们可以使用size属性或count()方法来获取映射中元素的总数：

例子

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    
    println("Size of the Map " + theMap.size)
    println("Size of the Map " + theMap.count())
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

Size of the Map 4
Size of the Map 4

containsKey() 和 containsValue() 方法

containsKey ()检查映射是否包含键。containsValue ()检查映射是否包含值。

例子

fun main() {
   val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)

   if(theMap.containsKey("two")){
      println(true)
   }else{
      println(false)
   }
   
   if(theMap.containsValue("two")){
      println(true)
   }else{
      println(false)
   } 
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

true
false

isEmpty() 方法

如果集合为空（不包含任何元素），isEmpty() 方法返回 true，否则返回false 。

例子

fun main() {
   val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    
   if(theMap.isEmpty()){
      println(true)
   }else{
      println(false)
   }
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

false

get() 方法

get ()方法可用于获取给定键对应的值。还支持简写[key]语法。

例子

fun main() {
   val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)

   println("The value for key two " + theMap.get("two"))
   println("The value for key two " + theMap["two"])
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

The value for key two 2
The value for key two 2

还有一个函数getValue()，它的Behave略有不同：如果在映射中找不到键，它会抛出异常。

地图添加

我们可以使用+运算符将两个或多个地图添加到一个集合中。这会将第二个地图添加到第一个地图中，并丢弃重复的元素。

如果两个映射中有重复的键，则第二个映射的键将覆盖前一个映射的键。

例子

fun main() {
    val firstMap = mapOf("one" to 1, "two" to 2, "three" to 3)
    val secondMap = mapOf("one" to 10, "four" to 4)
    val resultMap = firstMap + secondMap
    
    println(resultMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{one=10, two=2, three=3, four=4}

地图减法

我们可以使用-运算符从映射中减去列表。此操作将从映射中删除列表的所有键并返回结果。

例子

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3)
    val theKeyList = listOf("one", "four")
    val resultMap = theMap - theKeyList
    
    println(resultMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{two=2, three=3}

从地图中删除条目

我们可以使用remove()方法从可变映射中删除元素，也可以使用减号运算符(-=)来执行相同的操作

例子

fun main() {
    val theMap = mutableMapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    theMap.remove( "two")
    println(theMap)
    
    theMap -= listOf("three")
    println(theMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{one=1, three=3, four=4}
{one=1, four=4}

对地图元素进行排序

我们可以使用toSortedMap()方法对元素进行升序排序，或者使用sortedDescending()方法对集合元素进行降序排序。

您还可以使用sortedMapOf()方法使用给定的键/值创建排序映射。只需使用此方法代替mapOf()即可。

例子

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    var resultMap = theMap.toSortedMap()
    println(resultMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{four=4, one=1, three=3, two=2}

过滤地图元素

我们可以使用filterKeys()或filterValues()方法来过滤掉条目。

我们还可以使用filter()方法来过滤掉与键/值都匹配的元素

。

例子

fun main() {
    val theMap = mapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    var resultMap = theMap.filterValues{ it > 2}
    println(resultMap)
    
    resultMap = theMap.filterKeys{ it == "two"}
    println(resultMap)
    
    resultMap = theMap.filter{ it.key == "two" || it.value == 4}
    println(resultMap)
    
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{three=3, four=4}
{two=2}
{two=2, four=4}

映射地图元素

我们可以使用map()方法使用提供的函数来映射所有元素：。

例子

fun main() {
     val theMap = mapOf("one" to 1, "two" to 2, "three" to 3)
    val resultMap = theMap.map{ (k, v) -> "Key is $k, Value is $v" }
    
    println(resultMap)
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

[Key is one, Value is 1, Key is two, Value is 2, Key is three, Value is 3]

Kotlin 可变映射

我们可以使用mutableMapOf()创建可变集，稍后我们可以使用put在同一个映射中添加更多元素，并且我们可以使用remove()方法从集合中删除元素。

例子

fun main() {
     val theMap = mutableMapOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
    
    theMap.put("four", 4)
    println(theMap)
    
    theMap["five"] = 5
    println(theMap)
    
    theMap.remove("two")
    println(theMap)
    
}

当你运行上面的 Kotlin 程序时，它将生成以下输出：

{one=1, two=2, three=3, four=4}
{one=1, two=2, three=3, four=4, five=5}
{one=1, three=3, four=4, five=5}