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)
}
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 地球OL攻略 —— 某应届生求职总结
· 提示词工程——AI应用必不可少的技术
· 字符编码：从基础到乱码解决
· SpringCloud带你走进微服务的世界