43_集合_Map

1.Map的分类

  * TODO: Map的分类
  *     1.不可变 Map
  *     2.可变 Map(mutable.Map)

2.可变Map 和 不可变Map的区别

  * TODO: 可变Map 和 不可变Map的区别
  *     Map 的可变和不可变 指的是Map初始化后 是否可以被修改(增加、减少、修改元素)
  *     这也就造成了 它们相关算子 的功能不同
  *         例如:
  *             可变Map 增加、删除、修改元素后 是对本身的修改
  *             不可变Map 不支持 对本身的修改
  *                      增加、删除元素后 是返回新的Map对象,本身并不会修改

3.可变Map 和 不可变Map的使用场景

  * TODO: 可变Map 和 不可变Map的使用场景
  *     可变Map:
  *         有对源Map修改的需求(增加或删除)
  *     不可变Map:
  *         Map元素个数固定,只对Map做查询操作

4.不可变 Map API

  /* 不可变 Map*/
  def valMapDef = {

    //定义 不可变Map
    var valMap: Map[String, Int] = Map[String, Int]("赵" -> 1, "钱" -> 2, "孙" -> 3, "李" -> 4, "周" -> 5)

    //TODO: 添加元素(修改源Map) 不支持

    //TODO: 添加元素(源Map不变,返回修改后Map)-有则更新,无则添加
    val map1: Map[String, Int] = valMap + ("郑" -> 6) //方式1
    val map2: Map[String, Int] = valMap.updated("王", 7) //方式2

    println(s"不可变Map:${valMap}") //不可变Map:Map(李 -> 4, 周 -> 5, 钱 -> 2, 孙 -> 3, 赵 -> 1)
    println("map1:" + map1) //map1:Map(李 -> 4, 郑 -> 6, 周 -> 5, 钱 -> 2, 孙 -> 3, 赵 -> 1)
    println("map2:" + map2) //map2:Map(李 -> 4, 周 -> 5, 王 -> 7, 钱 -> 2, 孙 -> 3, 赵 -> 1)

    //valMap("吴") = 6 //方式1(不支持) 运行时异常,Error:(288, 3) value update is not a member of Map[String,Int]
    //var x2 = valMap.put("王", 8) //方式3 不支持
    //var x3 = valMap.update("张", 9) //方式4 不支持

    println("===============删除元素=================================================================")
    //TODO 删除元素(根据key删除元素,不存在就返回复制原对象)
    //valMap.removed("李") // 方式1 低版本不支持
    var deleteMap: Map[String, Int] = valMap - ("李") // 方式2 返回修改后的新Map,源Map不变
    println("deleteMap:" + deleteMap)
    //deleteMap:Map(周 -> 5, 钱 -> 2, 孙 -> 3, 赵 -> 1)

    //TODO 清空Map(不支持)

  }

5.可变 Map API

  /* 可变 Map*/
  def mutableMapDef = {
    //定义 可变Map
    import scala.collection.mutable

    var muMap: mutable.Map[String, Int] = mutable.Map[String, Int]("赵" -> 1, "钱" -> 2, "孙" -> 3, "李" -> 4, "周" -> 5)

    //TODO: 添加元素-可变Map(有则更新,无则添加)
    var y1: Unit = muMap("y1") = 6 //方式1 返回空, 修改源Map
    var y2: mutable.Map[String, Int] = muMap += ("y2" -> 7) //方式2 返回修改后的Map,修改源Map
    var y3: Option[Int] = muMap.put("y3", 8) //方式3 返回修改后的value值,修改源Map
    var y4: Unit = muMap.update("y4", 9) //方式4 返回空,修改源Map
    val y5: mutable.Map[String, Int] = muMap.updated("y5", 10) //方式5 返回修改后的新Map,源Map不会修改
    val y6: mutable.Map[String, Int] = muMap += ("y6" -> 9) //方式6 返回修改后的新Map,源Map会修改

    println(s"可变Map:${muMap}")
    //可变Map:Map(张 -> 9, 赵 -> 1, 王 -> 8, 郑 -> 7, 孙 -> 3, 周 -> 5, 钱 -> 2, 吴 -> 6, 李 -> 4)

    println("y1:" + y1) //y1:()
    println("y2:" + y2) //y2:Map(张 -> 9, 赵 -> 1, 王 -> 8, 郑 -> 7, 孙 -> 3, 周 -> 5, 钱 -> 2, 吴 -> 6, 李 -> 4)
    println("y3:" + y3) //y3:Some(8)
    println("y4:" + y4) //y4:()
    println("y5:" + y5) //y4:()
    println("y6:" + y6) //y4:()

    println("===============删除元素=================================================================")
    //TODO: 删除元素
    val deleteValue: Option[Int] = muMap.remove("赵1") //方式1 返回被删除的value,修改源Map(key不存在时,返回None)
    println(s"deleteValue:${deleteValue}")
    //deleteValue:Some(1)
    println(s"muMap:${muMap}")
    //muMap:Map(y4 -> 9, y1 -> 6, 孙 -> 3, y3 -> 8, y6 -> 9, 周 -> 5, 钱 -> 2, y2 -> 7, 李 -> 4)

    val deleteMap: mutable.Map[String, Int] = muMap - ("赵") //方式2 返回被修改的Map,源Map不改变
    println(s"deleteMap:${deleteMap}")
    //deleteMap:Map(y4 -> 9, y1 -> 6, 孙 -> 3, y3 -> 8, y6 -> 9, 周 -> 5, 钱 -> 2, 李 -> 4, y2 -> 7)
    println(s"muMap:${muMap}")
    //muMap:Map(赵 -> 1, y4 -> 9, y1 -> 6, 孙 -> 3, y3 -> 8, y6 -> 9, 周 -> 5, 钱 -> 2, y2 -> 7, 李 -> 4)

    //TODO: 更新 value值(key存在则更新,不存在则添加)
    muMap("newKey") = 100
    //muMap.update("oldKey") = 99

    //TODO 清空Map
    val unit = muMap.clear()
    println(muMap) //Map()
  }

6.公共API (可变Map 和不可变Map)

  /* 公共方法(可变Map 和不可变Map)*/
  def publicOperatorMapDef = {
    var map = Map[String, Int]("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 4, "e" -> 5)
    var mumap = mutable.Map[String, Int]("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 4, "e" -> 5)


    //TODO 通过key 获取value
    //方式1(返回value值,当key不存在时 报运行时异常)
    val v1: Int = map("a")
    //val v2: Int = map("Na") //Exception in thread "main" java.util.NoSuchElementException: key not found: Na
    println(v1)
    //println(v2)

    val v11: Int = mumap("a")
    //val v22: Int = mumap("Na")
    println(v11)
    //println(v22)

    //方式2(返回Option[value]值,当key不存在时,返回None,不会报错)
    val v3: Option[Int] = map.get("a")
    val v4: Option[Int] = map.get("Na")
    println(v3) // Some(1)
    println(v4) // None

    //方式3(返回value值,当key不存在时,返回默认值) 推荐！！！
    val v5: Int = map.getOrElse("a", 1)
    val v6: Int = map.getOrElse("Na", 99)
    println(v5) // 1
    println(v6) // 99

    //TODO 更新 value值(mutableMap支持)
    var v7: Unit = mumap("a") = 100
    var v8: Unit = mumap.update("a1", 102)
    println(map)
    println(mumap)

    //TODO 获取key的集合
    val keys1: Iterable[String] = map.keys
    val keys2: collection.Set[String] = map.keySet
    val keys3: Iterator[String] = map.keysIterator
    println(keys1.mkString(","))
    println(keys2.mkString(","))
    println(keys3.mkString(","))

    //TODO 获取value的集合
    val values1: Iterable[Int] = mumap.values
    val values2: Iterator[Int] = mumap.valuesIterator
    println(values1.mkString(","))
    println(values2.mkString(","))

    //TODO 变量Map
    for (elem <- map) {
      println(elem)
    }

    //TODO foreach
    mumap.foreach(
      println(_)
    )

    //TODO 判断Map是否为空(为空-true 不为空-false)
    val empty: Boolean = map.isEmpty
    println(empty)

    //TODO 判断是否包含指定key
    var iscon: Boolean = map.contains("a")
    println(iscon)


  }

 7. 合并Map

  def MergeMap = {

    var map1 = Map[String, Int]("a" -> 1, "b" -> 1, "c" -> 1, "d" -> 1)
    var map3 = Map[String, Int]("a" -> 1, "b" -> 1, "c" -> 1, "d" -> 1)
    var map2 = Map[Int, Int](1 -> 1, 2 -> 1, 3 -> 1, 4 -> 1)
    var mumap1 = mutable.Map[String, Int]("x" -> 1, "y" -> 1, "z" -> 1, "m" -> 1)
    var mumap2 = mutable.Map[String, Int]("x" -> 11, "y" -> 22, "z" -> 33, "m1" -> 1)


    /*
    * TODO map1 ++ map2 算子:
    *   功能:
    *       返回一个 包含map1、map2所有key的新map对象
    *           map1和map2 相同的key,使用用map2的value值
    *           map1和map2 不相同的key,将 原来的(key,value)添加到新map
    *
    * */
    var merMap: Map[Any, Int] = map1 ++ map2
    println(merMap)
    //Map(1 -> 1, a -> 1, 2 -> 1, b -> 1, 3 -> 1, c -> 1, 4 -> 1, d -> 1)

    var merMap1: mutable.Map[String, Int] = mumap1 ++ mumap2
    println(merMap1)
    //Map(z -> 33, m -> 1, y -> 22, m1 -> 1, x -> 11)

    println("-----for 实现 map1 ++ map2 功能--------------------------------------------------")
    //TODO for 实现 map1 ++ map2 功能
    var tmpMap: mutable.Map[String, Int] = mutable.Map[String, Int]()

    var keySet: collection.Set[String] = mumap1.keySet ++ mumap2.keySet
    for (e <- keySet) {
      tmpMap(e) = mumap2.getOrElse(e, mumap1(e))
    }
    println(tmpMap)
    //Map(z -> 33, m -> 1, y -> 22, m1 -> 1, x -> 11)


    println("--------map1.foldLeft(map2)(value的合并规则)----------------------------------------------------")
    /*
    * TODO map1.foldLeft(map2)(value的合并规则) 算子
    *     功能:
    *         返回一个 包含map1、map2所有key的新map对象
    *             map1和map2 相同的key,根据传入的规则对 value进行合并
    *             map1和map2 不相同的key,将 原来的(key,value)添加到新map
    *     实现原理:
    *         map1.foldLeft(map2)(value的合并规则)
    *           1.遍历map1
    *           2.   每个map1的元素 与 map2 做Merge,并返回map2
    *           def foldLeft[B](z: B)(op: (B, A) => B): B = {
    *             var result = z
    *             this foreach (x => result = op(result, x))
    *             result
    *           }
    * */

    // 可变Map Merge (修改map2)
    println(mumap1)
    println(mumap2)
    var CustmuMap = mumap1.foldLeft(mumap2)(
      (m2, e) => {
        m2(e._1) = m2.getOrElse(e._1, 0) + e._2
        m2
      }
    )
    println(CustmuMap)
    println(mumap2)
    //Map(z -> 34, m -> 1, y -> 23, m1 -> 1, x -> 12)
    //Map(z -> 34, m -> 1, y -> 23, m1 -> 1, x -> 12)


    // 不可变Map Merge (返回新Map)
    var CustMap = map1.foldLeft(map3)(
      (m2, e) => {
        m2.updated(e._1, e._2 + m2.getOrElse(e._1, 0))
      }
    )
    println(CustMap)
    println(map3)
    //Map(a -> 2, b -> 2, c -> 2, d -> 2)
    //Map(a -> 1, b -> 1, c -> 1, d -> 1)
  }