Map & Tuple

一、映射(Map)

1.1 构造Map

  1. // 初始化一个空 map
  2. val scores01 = new HashMap[String, Int]
  4. // 从指定的值初始化 Map（方式一）
  5. val scores02 = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)
  7. // 从指定的值初始化 Map（方式二）
  8. val scores03 = Map(("hadoop", 10), ("spark", 20), ("storm", 30))

采用上面方式得到的都是不可变 Map(immutable map)，想要得到可变 Map(mutable map)，则需要使用：

  1. val scores04 = scala.collection.mutable.Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

1.2 获取值

  1. object ScalaApp extends App {
  3.   val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)
  5.   // 1.获取指定 key 对应的值
  6.   println(scores("hadoop"))
  8.   // 2. 如果对应的值不存在则使用默认值
  9.   println(scores.getOrElse("hadoop01", 100))
  10. }

1.3 新增/修改/删除值

可变 Map 允许进行新增、修改、删除等操作。

  1. object ScalaApp extends App {
  3.   val scores = scala.collection.mutable.Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)
  5.   // 1.如果 key 存在则更新
  6.   scores("hadoop") = 100
  8.   // 2.如果 key 不存在则新增
  9.   scores("flink") = 40
  11.   // 3.可以通过 += 来进行多个更新或新增操作
  12.   scores += ("spark" -> 200, "hive" -> 50)
  14.   // 4.可以通过 -= 来移除某个键和值
  15.   scores -= "storm"
  17.   for (elem <- scores) {println(elem)}
  18. }
  20. // 输出内容如下
  21. (spark,200)
  22. (hadoop,100)
  23. (flink,40)
  24. (hive,50)

不可变 Map 不允许进行新增、修改、删除等操作，但是允许由不可变 Map 产生新的 Map。

  1. object ScalaApp extends App {
  3.   val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)
  5.   val newScores = scores + ("spark" -> 200, "hive" -> 50)
  7.   for (elem <- scores) {println(elem)}
  9. }
  11. // 输出内容如下
  12. (hadoop,10)
  13. (spark,200)
  14. (storm,30)
  15. (hive,50)

1.4 遍历Map

  1. object ScalaApp extends App {
  3.   val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)
  5.   // 1. 遍历键
  6.   for (key <- scores.keys) { println(key) }
  8.   // 2. 遍历值
  9.   for (value <- scores.values) { println(value) }
  11.   // 3. 遍历键值对
  12.   for ((key, value) <- scores) { println(key + ":" + value) }
  14. }

1.5 yield关键字

可以使用 yield 关键字从现有 Map 产生新的 Map。

  1. object ScalaApp extends App {
  3.   val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)
  5.   // 1.将 scores 中所有的值扩大 10 倍
  6.   val newScore = for ((key, value) <- scores) yield (key, value * 10)
  7.   for (elem <- newScore) { println(elem) }
  10.   // 2.将键和值互相调换
  11.   val reversalScore: Map[Int, String] = for ((key, value) <- scores) yield (value, key)
  12.   for (elem <- reversalScore) { println(elem) }
  14. }
  16. // 输出
  17. (hadoop,100)
  18. (spark,200)
  19. (storm,300)
  21. (10,hadoop)
  22. (20,spark)
  23. (30,storm)

1.6 其他Map结构

在使用 Map 时候，如果不指定，默认使用的是 HashMap，如果想要使用 TreeMap 或者 LinkedHashMap，则需要显式的指定。

  1. object ScalaApp extends App {
  3.   // 1.使用 TreeMap,按照键的字典序进行排序
  4.   val scores01 = scala.collection.mutable.TreeMap("B" -> 20, "A" -> 10, "C" -> 30)
  5.   for (elem <- scores01) {println(elem)}
  7.   // 2.使用 LinkedHashMap,按照键值对的插入顺序进行排序
  8.   val scores02 = scala.collection.mutable.LinkedHashMap("B" -> 20, "A" -> 10, "C" -> 30)
  9.   for (elem <- scores02) {println(elem)}
  10. }
  12. // 输出
  13. (A,10)
  14. (B,20)
  15. (C,30)
  17. (B,20)
  18. (A,10)
  19. (C,30)

1.7 可选方法

  1. object ScalaApp extends App {
  3.   val scores = scala.collection.mutable.TreeMap("B" -> 20, "A" -> 10, "C" -> 30)
  5.   // 1. 获取长度
  6.   println(scores.size)
  8.   // 2. 判断是否为空
  9.   println(scores.isEmpty)
  11.   // 3. 判断是否包含特定的 key
  12.   println(scores.contains("A"))
  14. }

1.8 与Java互操作

  1. import java.util
  2. import scala.collection.{JavaConverters, mutable}
  4. object ScalaApp extends App {
  6.   val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)
  8.   // scala map 转 java map
  9.   val javaMap: util.Map[String, Int] = JavaConverters.mapAsJavaMap(scores)
  11.   // java map 转 scala map
  12.   val scalaMap: mutable.Map[String, Int] = JavaConverters.mapAsScalaMap(javaMap)
  14.   for (elem <- scalaMap) {println(elem)}
  15. }

二、元组(Tuple)

元组与数组类似，但是数组中所有的元素必须是同一种类型，而元组则可以包含不同类型的元素。

  1. scala> val tuple=(1,3.24f,"scala")
  2. tuple: (Int, Float, String) = (1,3.24,scala)

2.1 模式匹配

可以通过模式匹配来获取元组中的值并赋予对应的变量：

  1. scala> val (a,b,c)=tuple
  2. a: Int = 1
  3. b: Float = 3.24
  4. c: String = scala

如果某些位置不需要赋值，则可以使用下划线代替：

  1. scala> val (a,_,_)=tuple
  2. a: Int = 1

2.2 zip方法

  1. object ScalaApp extends App {
  3.    val array01 = Array("hadoop", "spark", "storm")
  4.   val array02 = Array(10, 20, 30)
  6.   // 1.zip 方法得到的是多个 tuple 组成的数组
  7.   val tuples: Array[(String, Int)] = array01.zip(array02)
  8.   // 2.也可以在 zip 后调用 toMap 方法转换为 Map
  9.   val map: Map[String, Int] = array01.zip(array02).toMap
  11.   for (elem <- tuples) { println(elem) }
  12.   for (elem <- map) {println(elem)}
  13. }
  15. // 输出
  16. (hadoop,10)
  17. (spark,20)
  18. (storm,30)
  20. (hadoop,10)
  21. (spark,20)
  22. (storm,30)

参考资料

  1. Martin Odersky . Scala 编程 (第 3 版)[M] . 电子工业出版社 . 2018-1-1
  2. 凯.S.霍斯特曼 . 快学 Scala(第 2 版)[M] . 电子工业出版社 . 2017-7