Scala 系列（七）—— 經常使用集合類型之 Map & Tuple

1、映射(Map)

1.1 構造Map

// 初始化一個空 map
val scores01 = new HashMap[String, Int]

// 從指定的值初始化 Map（方式一）
val scores02 = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

// 從指定的值初始化 Map（方式二）
val scores03 = Map(("hadoop", 10), ("spark", 20), ("storm", 30))

採用上面方式獲得的都是不可變 Map(immutable map)，想要獲得可變 Map(mutable map)，則須要使用：

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

1.2 獲取值

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // 1.獲取指定 key 對應的值
  println(scores("hadoop"))

  // 2. 若是對應的值不存在則使用默認值
  println(scores.getOrElse("hadoop01", 100))
}

1.3 新增/修改/刪除值

可變 Map 容許進行新增、修改、刪除等操做。

object ScalaApp extends App {

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

  // 1.若是 key 存在則更新
  scores("hadoop") = 100

  // 2.若是 key 不存在則新增
  scores("flink") = 40

  // 3.能夠經過 += 來進行多個更新或新增操做
  scores += ("spark" -> 200, "hive" -> 50)

  // 4.能夠經過 -= 來移除某個鍵和值
  scores -= "storm"

  for (elem <- scores) {println(elem)}
}

// 輸出內容以下
(spark,200)
(hadoop,100)
(flink,40)
(hive,50)

不可變 Map 不容許進行新增、修改、刪除等操做，可是容許由不可變 Map 產生新的 Map。

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  val newScores = scores + ("spark" -> 200, "hive" -> 50)

  for (elem <- scores) {println(elem)}

}

// 輸出內容以下
(hadoop,10)
(spark,200)
(storm,30)
(hive,50)

1.4 遍歷Map

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // 1. 遍歷鍵
  for (key <- scores.keys) { println(key) }

  // 2. 遍歷值
  for (value <- scores.values) { println(value) }

  // 3. 遍歷鍵值對
  for ((key, value) <- scores) { println(key + ":" + value) }

}

1.5 yield關鍵字

能夠使用 yield 關鍵字從現有 Map 產生新的 Map。

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // 1.將 scores 中全部的值擴大 10 倍
  val newScore = for ((key, value) <- scores) yield (key, value * 10)
  for (elem <- newScore) { println(elem) }


  // 2.將鍵和值互相調換
  val reversalScore: Map[Int, String] = for ((key, value) <- scores) yield (value, key)
  for (elem <- reversalScore) { println(elem) }

}

// 輸出
(hadoop,100)
(spark,200)
(storm,300)

(10,hadoop)
(20,spark)
(30,storm)

1.6 其餘Map結構

在使用 Map 時候，若是不指定，默認使用的是 HashMap，若是想要使用 TreeMap 或者 LinkedHashMap，則須要顯式的指定。

object ScalaApp extends App {

  // 1.使用 TreeMap,按照鍵的字典序進行排序
  val scores01 = scala.collection.mutable.TreeMap("B" -> 20, "A" -> 10, "C" -> 30)
  for (elem <- scores01) {println(elem)}

  // 2.使用 LinkedHashMap,按照鍵值對的插入順序進行排序
  val scores02 = scala.collection.mutable.LinkedHashMap("B" -> 20, "A" -> 10, "C" -> 30)
  for (elem <- scores02) {println(elem)}
}

// 輸出
(A,10)
(B,20)
(C,30)

(B,20)
(A,10)
(C,30)

1.7 可選方法

object ScalaApp extends App {

  val scores = scala.collection.mutable.TreeMap("B" -> 20, "A" -> 10, "C" -> 30)

  // 1. 獲取長度
  println(scores.size)

  // 2. 判斷是否爲空
  println(scores.isEmpty)

  // 3. 判斷是否包含特定的 key
  println(scores.contains("A"))

}

1.8 與Java互操做

import java.util
import scala.collection.{JavaConverters, mutable}

object ScalaApp extends App {

  val scores = Map("hadoop" -> 10, "spark" -> 20, "storm" -> 30)

  // scala map 轉 java map
  val javaMap: util.Map[String, Int] = JavaConverters.mapAsJavaMap(scores)

  // java map 轉 scala map
  val scalaMap: mutable.Map[String, Int] = JavaConverters.mapAsScalaMap(javaMap)
  
  for (elem <- scalaMap) {println(elem)}
}

2、元組(Tuple)

元組與數組相似，可是數組中全部的元素必須是同一種類型，而元組則能夠包含不一樣類型的元素。

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

2.1 模式匹配

能夠經過模式匹配來獲取元組中的值並賦予對應的變量：

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

若是某些位置不須要賦值，則能夠使用下劃線代替：

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

2.2 zip方法

object ScalaApp extends App {

   val array01 = Array("hadoop", "spark", "storm")
  val array02 = Array(10, 20, 30)
    
  // 1.zip 方法獲得的是多個 tuple 組成的數組
  val tuples: Array[(String, Int)] = array01.zip(array02)
  // 2.也能夠在 zip 後調用 toMap 方法轉換爲 Map
  val map: Map[String, Int] = array01.zip(array02).toMap
    
  for (elem <- tuples) { println(elem) }
  for (elem <- map) {println(elem)}
}

// 輸出
(hadoop,10)
(spark,20)
(storm,30)

(hadoop,10)
(spark,20)
(storm,30)

參考資料

1. Martin Odersky . Scala 編程 (第 3 版)[M] . 電子工業出版社 . 2018-1-1
   
2. 凱.S.霍斯特曼 . 快學 Scala(第 2 版)[M] . 電子工業出版社 . 2017-7

更多大數據系列文章能夠參見 GitHub 開源項目： 大數據入門指南