操作整理
scala的可变不可变的Map集合，整理增删改查合并遍历排序流操作等操作
- 创建Map
- 可变和不可变转换
- 和其他集合互转
- Map增加元素
- Map删除元素
- 查看元素
- Map之间合并
- Map的map操作
- filter
- 循环
- 排序取前key
- 判断是否包含
- inc自增
- max & min 最大最小元素
代码demo
- 创建Map
def createMap(): Unit = {
println("-" * 30)
// 不可变Map
val a = Map("a" -> 1, "b" -> 2)
// 可变Map
val b = mutable.Map("a" -> 1, "b" -> 2)
val d = mutable.HashMap("a" -> 1, "b" -> 2)
val c = mutable.HashMap[String, Int]()
c.put("a", 1)
c.put("b", 2)
}
- 可变和不可变转换
def mutable2immutable(): Unit = {
println("-" * 30)
val a = Map("a" -> 1, "b" -> 2)
// 可不变转可变, _*转化为参数序列
val b = mutable.Map(a.toSeq: _*)
b.put("c", 3)
// 可变转不可变
val c = b.toMap
}
- 和其他集合互转
def otherCollectionTransform(): Unit = {
println("-" * 30)
val a = Map("a" -> 1, "b" -> 2)
// Map->转化为List,不可变
val b = a.toList
println(b)
// list转化为Map
val c = List(("a", 1), ("b", 2))
val d = c.toMap
println(d)
// Map -> Buffer
val e = a.toBuffer // ArrayBuffer((a,1), (b,2))
// a.toSeq
println(e)
e.append(("c", 3))
println(e)
val f = e.toMap
println(f)
// 转化为Iterator
println("转为迭代器")
val h = a.toIterator
println(h) // non-empty iterato
val tmpMap = h.next()
println(tmpMap)
}
- Map增加元素
def addKeyValue(): Unit = {
println("-" * 30)
// 创建一个空的可变HashMap
val a = mutable.HashMap[String, Int]()
a.put("a", 1)
// 增加单个kv是+， 增加多个kv（map）是++
a += ("b" -> 2)
a("c") = 3
println(a)
// put和（）同样适用于修改value
}
- Map删除元素
def removeKeyValue(): Unit = {
println("-" * 30)
val a = mutable.HashMap[String, Int]("a" -> 3, "b" -> 2, "c" -> 1)
println(a)
a -= ("a")
// -= 可以删除多个key
println("删除多个元素")
a -= ("b", "c")
// a.remove("b")
}
- 查看元素
def searchKeyValue(): Unit = {
println("-" * 30)
val a = mutable.HashMap[String, Int]("a" -> 3, "b" -> 2, "c" -> 1)
val b: Int = a.getOrElse("a", 5)
println(b)
// get结果是Option对象，有值需要再get
val c: Int = a.get("b").get
// 无值直接报错
val d: Int = a("b")
}
- Map之间合并
def mergeKeyValue(): Unit = {
// ++ 相当于 addAll
println("-" * 30)
// 简单合并(覆盖)
val a = mutable.HashMap[String, Int]("a" -> 3, "b" -> 2, "c" -> 1)
val b = mutable.HashMap[String, Int]("d" -> 3, "e" -> 2, "a" -> 1)
// 可变Map可以是++=，不可变Map没有=
a ++= b
println(a) // Map(e -> 2, b -> 2, d -> 3, a -> 1, c -> 1)
val c = mutable.HashMap[String, Int]("a" -> 3, "b" -> 2, "c" -> 1)
val d = mutable.HashMap[String, Int]("d" -> 3, "e" -> 2, "a" -> 1)
// 合并的时候出现重复的key，后面的覆盖前面的value
val e = d ++ c
println(e) // Map(e -> 2, b -> 2, d -> 3, a -> 3, c -> 1)
// 条件合并
// 同key求和, 先运行后面的map，再覆盖前面的names
val names = Map("Sidney" -> 2, "Paul" -> 1, "Jacob" -> 7)
val moreNames = Map("Sidney" -> 1, "Paul" -> 5, "Nick" -> 2)
val mergeMap = names ++ moreNames.map {
case (k, v) => k -> (v + names.getOrElse(k, 0))
}
println(mergeMap)
// 等同于
val mergeMap2 = names ++ moreNames.map(x => x._1 -> (names.getOrElse(x._1, 0) + x._2))
println(mergeMap2)
// 等同于
val tmpMap = mutable.HashMap[String, Int]()
for ((k: String, v: Int) <- names.toSeq ++ moreNames.toSeq) {
tmpMap.put(k, tmpMap.getOrElse(k, 0) + v)
}
println(tmpMap)
tmpMap.clear()
// 等同于
(names.toSeq ++ moreNames.toSeq).foreach(x => tmpMap.put(x._1, tmpMap.getOrElse(x._1, 0) + x._2))
println(tmpMap)
tmpMap.clear()
// 同key的value合并为一个List
val tmpMap2 = mutable.HashMap[String, ListBuffer[Int]]()
for ((k: String, v: Int) <- names.toSeq ++ moreNames.toSeq) {
if (!tmpMap2.contains(k)) {
tmpMap2.put(k, ListBuffer[Int]())
}
tmpMap2(k).append(v)
}
println(tmpMap2)
tmpMap2.clear()
// 等同于
(names.toSeq ++ moreNames.toSeq).foreach(x => {
if (!tmpMap2.contains(x._1)) {
tmpMap2.put(x._1, ListBuffer[Int]())
}
tmpMap2(x._1).append(x._2)
})
println(tmpMap2)
tmpMap2.clear()
// 同一个key取最大值
val tmpMap3 = mutable.HashMap[String, Int]()
(names.toSeq ++ moreNames.toSeq).foreach(x => {
if (x._2 > tmpMap3.getOrElse(x._1, x._2 - 1)) {
tmpMap3.put(x._1, x._2)
}
})
println(tmpMap3)
}
- Map的map操作
def mapTest(): Unit = {
val a = Map("a" -> List(1, 2, 3), "b" -> List(4, 1, 3), "c" -> List(10, 1, 4))
println(a)
// 求最大
val b = a.map(x => x._1 -> x._2.max)
println(b)
// value类型转换
val c = Map("a" -> ListBuffer("a", "b"), "b" -> ListBuffer("a", "b"))
println(c)
val d = c.map(x => x._1 -> x._2.toList)
println(d)
// kv反转
val e = Map("a" -> "b", "c" -> "d")
println(e)
val f = e.map(x => x._2 -> x._1)
println(f)
}
- filter
def filterTest(): Unit = {
val a = Map("a" -> 1, "c" -> 2, "b" -> 5, "e" -> 3)
val b = a.filter(_._2 > 3)
println(b)
println(a.filter(_._2 > 3).size)
val c = a.filter(x => List("a", "e").contains(x._1))
println(c)
}
- 循环
def loopTest(): Unit = {
// for循环
val a = Map[String, Int]("a" -> 1, "b" -> 2, "c" -> 3)
for ((k, v) <- a) {
println(k)
println(v)
}
// 循环增加守卫条件
for ((k, v) <- a if (k != "b")) {
println(k)
println(v)
}
// foreach循环
// case要是花括号
a.foreach { case (k, v) => {
println(k)
}
}
println("只有key")
for (k <- a.keys) {
println(k)
}
println("只有value")
for (v <- a.values) {
println(v)
}
}
- 排序取前key
def sortTopTest(): Unit = {
val a = Map("a" -> 3, "b" -> 4, "d" -> 9, "c" -> 11, "e" -> 5)
// Map本身没有sort，先转化为Seq
val b: List[String] = a.toSeq.sortWith(_._2 > _._2).slice(0, 2).map(_._1).toList
println(b) // List(c, d)
}
- 判断是否包含
def otherOperation(): Unit = {
val a = Map("a" -> 3, "b" -> 4, "d" -> 9, "c" -> 11, "e" -> 5)
// 是否包含
println(a.contains("a"))
// 获得所有的key
println(a.keys) // Set
println(a.keySet)
// 获得所有的value
println(a.values)
}
- inc自增
def inrCountTest(): Unit = {
// 记录一个常用的自增计数函数
val a = List(1, 2, 1, 3, 4, 4, 5, 6, 5, 5, 5, 3, 2, 1, 9, 5)
val b = mutable.HashMap[Int, Int]()
a.foreach(x => {
b.put(x, b.getOrElse(x, 0) + 1)
})
println(b)
val c = List((1, 2), (3, 2), (9, 9), (1, 4), (2, 4), (3, 1))
val d = mutable.HashMap[Int, Int]()
for ((x, y) <- c) {
d.put(x, d.getOrElse(x, 0) + y)
}
println(d)
}
- max & min
def statisTest(): Unit = {
val a = Map("a" -> 2, "c" -> 9, "e" -> 4)
println(a.maxBy(_._2))
val res: String = a.minBy(_._2)._1 // minBy的结果是一个tuple
println(res)
}
网友评论