Kotlin 简明教程

Kotlin - Maps

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

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

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

Creating Kotlin Maps

对于地图创建，使用标准库函数 mapOf() 适用于只读地图， mutableMapOf() 适用于可变地图。

Example

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)]

Creating Map using HashMap

Kotlin map 可以从 Java 的 HashMap 创建。

Example

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}

Using Pair while Creating Map

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

Example

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

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

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

Kotlin Properties

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

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]

Loop through Kotlin Maps

遍历 Kotlin Maps 有多种方法。让我们逐个研究它们：

Using toString() function

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}

Using Iterator

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

Using For Loop

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

Using 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

Size of Kotlin Map

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

Example

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

The containsKey() & containsValue() Methods

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

Example

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

The isEmpty() Method

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

Example

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

The get() Method

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

Example

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

Map Addition

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

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

Example

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}

Map Subtraction

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

Example

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}

Removing Entries from Map

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

Example

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}

Sorting Map Elements

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

您还可以使用 sortedMapOf() 方法创建一个包含给定键/值的排序映射。只要将此方法用在 mapOf() 的位置即可。

Example

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}

Filtering Map Elements

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

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

Example

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}

Mapping Map Elements

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

Example

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 Mutable Map

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

Example

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}