Scala中的Map集合

1. Map集合

1.1 Scala中的Map介绍

Scala中的Map 和Java类似，也是一个散列表，它存储的内容也是键值对(key-value)映射，Scala中不可变的Map是有序的，可变的Map是无序的。

Scala中，有可变Map (scala.collection.mutable.Map) 和 不可变Map(scala.collection.immutable.Map)

1.2 构建map

1. 构建不可变map

​ Scala中的不可变Map是有序，构建Map中的元素底层是Tuple2类型。

val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")

• 不可变map，输出顺序和声明顺序一致
• 构建Map集合中，集合中的元素其实是Tuple2类型
• 默认情况下（即没有引入其它包的情况下）,Map是不可变map

2. 构建可变map //需要指定可变Map的包

val map2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)

​ 说明：可变map输出顺序和声明顺序不一致

3. 构建空map

val map3 = new scala.collection.mutable.HashMap[String, Int]

4. 使用对偶元组，构建map

​ 即创建包含键值对的二元组， 和第一种方式等价，只是形式上不同而已。对偶元组 就是只含有两个数据的元组。

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )

1.3 Map操作

1. 添加map元素

​ 方式1-增加单个元素

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4 += ( "D" -> 4 )
map4 += ( "B" -> 50 )
println(map4)

​ 思考：如果增加的key 已经存在会怎么样？

​ 如果在添加元素的时候，对应的key已经存在，则会更新key所对应的value值。

2. 方式2-增加多个元素

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
val map5 = map4 + ("E"->1, "F"->3)
map4 += ("EE"->1, "FF"->3)  

3. 删除map元素

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4 -= ("A", "B")
println("map4=" + map4)

说明

• "A","B" 就是要删除的key, 可以写多个.
• 如果key存在，就删除，如果key不存在，也不会报错.

1.4 Map取值

1. 方式1-使用map(key)

val value1 = map2("Alice") 
println(value1)

说明:

• 如果key存在，则返回对应的值
• 如果key不存在，则抛出异常[java.util.NoSuchElementException]
• 在Java中,如果key不存在则返回null

2. 方式2-使用contains方法检查是否存在key

​ // 返回Boolean
​ // 1.如果key存在，则返回true
​ // 2.如果key不存在，则返回false
​ map4.contains("B")

​ 说明:使用containts先判断在取值，可以防止异常，并加入相应的处理逻辑

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30.9) )
if( map4.contains("B") ) {
println("key存在值= " + map4("B"))
} else {
println("key不存在")
}

3. 方式3-使用map.get(key).get取值
   通过调用“.get”方法，返回一个Option对象，要么是Some，要么是None

var map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.get("A")) //Some
println(map4.get("A").get) //得到Some在取出

说明和小结:

• map.get方法会将数据进行包装
• 如果 map.get(key) key存在返回some,如果key不存在，则返回None
• 如果 map.get(key).get key存在，返回key对应的值,否则，抛出异常java.util.NoSuchElementException: None.get

4. 方式4-使用map4.getOrElse()取值

getOrElse 方法 : def getOrElse[V1 >: V](key: K, default: => V1)

说明：

• 如果key存在，返回key对应的值。
• 如果key不存在，返回默认值。在java中底层有很多类似的操作。

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.getOrElse("A","默认"))

5. 取值方式选择建议
   • 若能确定map有key ,使用map(key), 速度快
   • 若不能确定map是否有key ,而且有不同的业务逻辑，使用map.contains() ，先判断再加入逻辑
   • 若只是得到一个值，使用map4.getOrElse("ip","127.0.0.1")

1.5 更新Map

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4("AA") = 20
println(map4)

• map 是可变的，才能修改，否则报错
• 如果key存在：则修改对应的值,key不存在,等价于添加一个key-value

1.6 Map遍历

val map1 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
for ((k, v) <- map1) println(k + " is mapped to " + v)//模式匹配的方式
for (v <- map1.keys) println(v)//打印Key
for (v <- map1.values) println(v)//打印value
for(v <- map1) println(v) //v是Tuple

说明
1.每遍历一次，返回的元素是Tuple2
2.取出的时候，可以按照元组的方式来取

1.7 综合应用实例

object MapDemo01 {
  def main(args: Array[String]): Unit = {

    //方式1-构造不可变映射
    //1.默认Map是 immutable.Map
    //2.key-value 类型支持Any
    //3.在Map的底层，每对key-value是Tuple2
    //4.从输出的结果看到，输出顺序和声明顺序一致
    val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
    println(map1)


    //方式2-构造可变映射
    //1.从输出的结果看到，可变的map输出顺序和声明顺序不一致
    val map2 = mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
    println(map2)

    //方式3-创建空的映射

    val map3 = new scala.collection.mutable.HashMap[String, Int]
    println("map3=" + map3)

    //方式4-对偶元组
    val map4 = mutable.Map(("Alice", 10), ("Bob", 20), ("Kotlin", "北京"))
    println("map4=" + map4)

    map4 += ( "D" -> 4 )
    map4 += ( "B" -> 50 )

    println("map4=" +map4)

    //方式1-使用map(key)
    println(map4("Alice")) // 10
    //抛出异常（java.util.NoSuchElementException: key not found:）
    //println(map4("Alice~"))

    //方式2-使用contains方法检查是否存在key
    if (map4.contains("Alice")) {
      println("key存在，值=" + map4("Alice"))
    } else {
      println("key不存在:)")
    }

    //方式3 方式3-使用map.get(key).get取值
    //1. 如果key存在 map.get(key) 就会返回Some(值)  ,然后Some(值).get就可以取出
    //2. 如果key不存在 map.get(key) 就会返回None

    println(map4.get("Alice").get)
    //println(map4.get("Alice~").get)  // 抛出异常

    //方式4-使用map4.getOrElse()取值
    println(map4.getOrElse("Alice~~~", "默认的值 鱼 <・)))><<"))


    val map5 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
    map5("A") = 20 //增加
    println("map5=" + map5)

    map5 += ("A" -> 100)
    println("map5=" + map5)


    val mapVar = map5 + ("E"->1, "F"->3)
    println("mapVar=" + mapVar)
    map5 += ("GG"->1, "HH"->3)
    println("map5=" + map5)


    map5 -= ("A", "B", "AAA") //
    println("map5=" + map5)

    //map的遍历
    val map6 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
    println("----(k, v) <- map6--------")
    for ((k, v) <- map6) println(k + " is mapped to " + v)

    println("----v <- map6.keys--------")
    for (v <- map6.keys) println(v)
    println("----v <- map6.values--------")
    for (v <- map6.values) println(v)

    //这样取出方式 v 类型是 Tuple2
    println("----v <- map6--------")
    for (v <- map6) println(v + " key =" + v._1 + " val=" + v._2) //v是Tuple?

    val map7 = mutable.Map(("Alice", 10), ("Bob", 20), ("Kotlin", "北京"))
    val map8 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
    map7 ++= map8
    println("map7=" + map7) //map7=Map(Bob -> 20, A -> 1, Kotlin -> 北京, C -> 3, Alice -> 10, B -> 北京)
    val map9=map7 ++ map8
    println("map9=" + map9) //map9=Map(Bob -> 20, Kotlin -> 北京, A -> 1, C -> 3, Alice -> 10, B -> 北京)
    
  }
}