主要内容

  • Map的创建
  • 方式1：to
  • 方式2：Pair
  • Map值的读取
  • 方式1：[] 找不到会返回null
  • 方式2：getOrDefault()
  • 方式3：getOrElse()
  • 方式4：getValue()
  • 相关代码
  • Map集合遍历
  • 方式1：forEach
  • 方式2：forEach{ K,V -> }
  • 方式3：forEach{ (K,V) -> }
  • 方式4：for
  • 相关代码
  • 可变Map集合学习
  • 创建可变Map：mutableMapOf
  • 可变Map：添加、删除
  • 可变Map：getOrPut()
  • 相关代码


Map的创建

方式1：to

val mMap1:Map<String,Double> = mapOf("Derry" to (534.4),"Kevin" to 45.6)

方式2：Pair

val mMap2 = mapOf(Pair("Derry",534.4),Pair("Kevin",45.6))

Map值的读取

val mapOf = mapOf("Derry" to 123, "Kevin" to 654)

方式1：[] 找不到会返回null

//背后对[]运算符重载
 mapOf["Derry"]
 //get与[]是等价的
 mapOf.get("Derry")
 //map 通过key找，如果找不到返回null，不会崩溃
 mapOf["xxx"]

方式2：getOrDefault()

mapOf.getOrDefault("Derry",0) //map中存在
mapOf.getOrDefault("Derry2",0)//map中不存在

方式3：getOrElse()

参数2是lambda表达式
mapOf.getOrElse("Derry"){ -1 }//map中存在
mapOf.getOrElse("Derry2"){ -1 }//map中不存在//map中不存在

方式4：getValue()

mapOf.getValue("Derry")
//如果key不存在程序会崩溃，尽量不要使用方式
mapOf.getValue("xxx")

相关代码

map获取方式尽量使用方式2、方式3
完整代码如下
fun main() {
    val mapOf = mapOf("Derry" to 123, "Kevin" to 654)

    //方式1 [] 找不到会返回null
    println("方式1 []")
    println(mapOf["Derry"])//背后对[]运算符重载
    println(mapOf.get("Derry"))//get与[]是等价的
    println(mapOf["xxx"])//map 通过key找，如果找不到返回null，不会崩溃

    //方式2 getOrDefault
    println()
    println("方式2 getOrDefault")
    println(mapOf.getOrDefault("Derry",0))
    println(mapOf.getOrDefault("Derry2",0))

    //方式3 getOrElse 参数2是lambda表达式
    println()
    println("方式3 getOrElse")
    println(mapOf.getOrElse("Derry"){ -1 })
    println(mapOf.getOrElse("Derry2"){ -1 })

    //方式4 getValue 与Java一样 会崩溃，尽量不要使用方式
    println()
    println("方式4 getValue")
    println(mapOf.getValue("Derry"))
    //println(mapOf.getValue("xxx"))
}
运行结果
方式1 []
123
123
null

方式2 getOrDefault
123
0

方式3 getOrElse
123
-1

方式4 getValue
123

Map集合遍历

方式1：forEach

mapOf.forEach {
        //it 内容 每一个元素（K 和 V）
        //it 类型 Map.Entry<String,Int>
        println("K:${it.key} V:${it.value}")
}

方式2：forEach{ K,V -> }

mapOf.forEach { key, value ->
        //把默认的it覆盖
        println("key:${key} value:${value}")
}

方式3：forEach{ (K,V) -> }

mapOf.forEach { (key, value) ->
        //key:String
        //value:Int
        println("key:${key} value:${value}")
}

方式4：for

for (item in mapOf) {
        //item 内容 每一个元素（K 和 V）
        //item 类型 Map.Entry<String,Int>
        println("K:${item.key} V:${item.value}")
}

相关代码

fun main() {

    val mapOf = mapOf("Derry" to 123, Pair("Kevin", 456), "Leo" to 789)

    //方式1
    println("方式1")
    mapOf.forEach {
        //it 内容 每一个元素（K 和 V）
        //it 类型 Map.Entry<String,Int>
        println("K:${it.key} V:${it.value}")
    }

    //方式2
    println()
    println("方式2")
    mapOf.forEach { key, value ->
        //把默认的it覆盖
        println("key:${key} value:${value}")
    }

    //方式3
    println()
    println("方式3")
    mapOf.forEach { (key, value) ->
        //key:String
        //value:Int
        println("key:${key} value:${value}")
    }

    //方式4
    println()
    println("方式4")
    for (item in mapOf) {
        //item 内容 每一个元素（K 和 V）
        //item 类型 Map.Entry<String,Int>
        println("K:${item.key} V:${item.value}")
    }
}
运行结果
方式1
K:Derry V:123
K:Kevin V:456
K:Leo V:789

方式2
key:Derry value:123
key:Kevin value:456
key:Leo value:789

方式3
key:Derry value:123
key:Kevin value:456
key:Leo value:789

方式4
K:Derry V:123
K:Kevin V:456
K:Leo V:789

可变Map集合学习

创建可变Map：mutableMapOf

val mutableMapOf = mutableMapOf("Derry" to 123, Pair("Kevin", 456), Pair("Dee", 789))

可变Map：添加、删除

mutableMapOf += "AAA" to (111) //map增加AAA
    mutableMapOf += "BBB" to 1234 //map增加BBB
    mutableMapOf -= "Kevin" //map移除Kevin
    mutableMapOf["CCC"] = 888 //map增加CCC
    mutableMapOf.put("DDD", 999)//put 和[]等价

可变Map：getOrPut()

//getOrPut 没有的情况下
    //如果整个map集合里面没有FFF的key元素，我就帮你先添加到map集合中，然后再从map中获取
    val orPut = mutableMapOf.getOrPut("FFF") { 555 }
    println("orPut:${orPut}")


    //getOrPut 有的情况下
    //发现Derry的Key是有的，那么久直接获取出来，相当于666就失效了
    val orPut1 = mutableMapOf.getOrPut("Derry") { 666 }
    println("orPut1:${orPut1}")

相关代码

fun main() {
    val mutableMapOf = mutableMapOf("Derry" to 123, Pair("Kevin", 456), Pair("Dee", 789))

    //1、可变集合的操作 +=[] put
    mutableMapOf += "AAA" to (111)
    mutableMapOf += "BBB" to 1234
    mutableMapOf -= "Kevin"
    mutableMapOf["CCC"] = 888
    mutableMapOf.put("DDD", 999)//put 和[]等价

    //2、getOrPut 没有的情况下
    //如果整个map集合里面没有FFF的key元素，我就帮你先添加到map集合中，然后再从map中获取
    val orPut = mutableMapOf.getOrPut("FFF") { 555 }
    println("orPut:${orPut}")


    //3、getOrPut 有的情况下
    //发现Derry的Key是有的，那么久直接获取出来，相当于666就失效了
    val orPut1 = mutableMapOf.getOrPut("Derry") { 666 }
    println("orPut1:${orPut1}")

}
运行结果
orPut:555
orPut1:123