概述

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

Map映射 默认不可变, 具体的实现是HashMap
scala的Map, 把键和值当做元组(对偶)来处理

不可变Map

1）说明
（1）创建不可变集合Map
（2）循环打印
（3）访问数据
（4）如果key不存在，返回0
2）案例实操

  1. object TestMap {
  2.     def main(args: Array[String]): Unit = {
  3.         // Map
  4.         //（1）创建不可变集合Map
  5.         val map = Map( "a"->1, "b"->2, "c"->3 )
  6.         //（3）访问数据
  7.         for (elem <- map.keys) {
  8.             // 使用get访问map集合的数据，会返回特殊类型Option(选项):有值（Some），无值(None)
  9.             println(elem + "=" + map.get(elem).get)
  10.         }
  11.         //（4）如果key不存在，返回0
  12.         println(map.get("d").getOrElse(0))
  13.         println(map.getOrElse("d", 0))
  14.         //（2）循环打印
  15.         map.foreach((kv)=>{println(kv)})
  16.     }
  17. }

可变Map

1）说明
（1）创建可变集合
（2）打印集合
（3）向集合增加数据
（4）删除数据
（5）修改数据
2）案例实操

  1. object TestSet {
  2.     def main(args: Array[String]): Unit = {
  3.         //（1）创建可变集合
  4.         val map = mutable.Map( "a"->1, "b"->2, "c"->3 )
  5.         //（3）向集合增加数据
  6.         map.+=("d"->4)
  7.         // 将数值4添加到集合，并把集合中原值1返回
  8.         val maybeInt: Option[Int] = map.put("a", 4)
  9.         println(maybeInt.getOrElse(0))
  10.         //（4）删除数据
  11.         map.-=("b", "c")
  12.         //（5）修改数据
  13.         map.update("d",5)
  14. map("d") = 5
  15.         //（2）打印集合
  16.         map.foreach((kv)=>{println(kv)})
  17.     }
  18. }

遍历

遍历元祖

  1. val map1: Map[String, Int] = Map[String, Int](("a", 97), ("b", 98), ("c", 99), ("d", 98))<br />    //遍历<br />    for (kv <- map1) {<br />      println(kv)<br />    }

输出:
(a,97)
(b,98)
(c,99)
(d,98)

遍历分别获取Key和value

  1. val map1: Map[String, Int] = Map[String, Int](("a", 97), ("b", 98), ("c", 99), ("d", 98))<br />    //<br />    for ((k, v) <- map1) { //<br />      println(k + "--" + v)<br />    }

输出 :
a—97
b—98
c—99
d—98

获取指定value值的key

  1. val map1: Map[String, Int] = Map[String, Int](("a", 97), ("b", 98), ("c", 99), ("d", 98))<br />    //我只是想要value为 98 的key<br />    for ((k, 98) <- map1) {<br />      println(k)<br />    }

输出:
b
d


设置值

如果key存在就是更新操作,如果key不存在就是添加操作

  1. // 初始化Map<br />    val map1: Map[String, Int] = Map[String, Int](<br />            "a" -> 97,<br />            "x"-> 0,<br />            "b" -> 98,<br />            "c" -> 99)<br />        <br />        val map2 = map1 + ("a" -> 102)<br />        println(map2)  // 输出: Map(a -> 102, x -> 0, b -> 98, c -> 99)

两个Map合并

两个Map进行合并,如果key重复了,那么后面的Map的值会覆盖前面的相同的key的value值,比如说第一个Map里面有个key为a的值为97,第二个Map里面也有个key为a,但是值是970,那么两个Map合并之后,a的value为970 ,那么就是后面的覆盖掉前面的值.

val map1: Map[String, Int] = MapString, Int
val map2: Map[String, Int] = MapString, Int
val map3 = map1 ++ map2
println(map3) // 输出: HashMap(x -> 0, a -> 970, b -> 980, c -> 990, z -> 1)

获取值

map1(“a”) // 这种方式几乎不用,如果获取的key没有的话,会抛异常出来
map1.get(“a”) //建议用这种的.

  1. val map1: Map[String, Int] = Map[String, Int](<br />      "a" -> 97,<br />      "x" -> 0,<br />      "b" -> 98,<br />      "c" -> 99)<br />    // 根据key获取值<br />    val v1: Int = map1("a") // 这种方式用的很少<br />    println(v1) // 输出: 97<br />    // val v2: Int = map1("f")  // 会抛异常<br />    //如果没有这个key的话,返回None<br />    val v3 = map1.get("f") //输出: None<br />    println(v3)<br />    // 存在就返回对应的value, <br />    //如果key存在话,就返回f的对应的value<br />    //如果key不存在, 就返回默认值<br />    val v4 = map1.getOrElse("f", 100)<br />    println(v4) // 输出: 100

可变Map

添加和获取值

val map1: mutable.Map[String, Int] = mutable.Map[String, Int](<br />      "a" -> 97,<br />      "x" -> 0,<br />      "b" -> 98,<br />      "c" -> 99)<br />    // 更新操作<br />    map1 += (("aa", 100))<br />    println(map1) // 输出: HashMap(x -> 0, aa -> 100, a -> 97, b -> 98, c -> 99)<br />    // 更新操作方式2<br />    map1 += "aa" -> 150<br />    println(map1) // 输出: HashMap(aa -> 150, a -> 97, b -> 98, c -> 99, x -> 0)<br />    val v1 = map1.getOrElse("f", 100)<br />    println(v1) // 输出 : 100<br />    // 如果f的值有的话就返回f的value值<br />    // 如果f这个key不存在, 则会组合一个新的kv, 添加到可变的map中<br />    val v2 = map1.getOrElseUpdate("f", 250)<br />    println(map1.get("f")) //输出: Some(250)

修改值

val map1: mutable.Map[String, Int] = mutable.Map[String, Int](<br />      "a" -> 97,<br />      "x" -> 0,<br />      "b" -> 98,<br />      "c" -> 99)<br />    // 获取值,如果获取不到就添加新值<br />    map1("a") = 100<br />    println(map1.get("a")) //输出 : Some(100)<br />    map1("f") = 150<br />    println(map1.get("f")) //输出 : Some(150)<br />    // 修改值,如果值不存在的话,就添加值<br />    map1.update("dd", 200)<br />    println(map1.get("dd")) //输出 : Some(200)<br />    map1.update("c", 250)<br />    println(map1.get("c")) //输出 : Some(250)