入門大資料---Scala_Map和Tuple
阿新 • • 發佈:2020-06-29
一、對映(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 {
//使用 LinkedHashMap,按照鍵值對的插入順序進行排序
val scores02 = scala.collection.mutable.LinkedHashMap("B" -> 20, "A" -> 10, "C" -> 30)
for (elem <- scores02) {println(elem)}
}
// 輸出
(B,20)
(A,10)
(C,30)
1.7 可選方法
object ScalaApp extends App {
val scores = scala.collection.mutable.HashMap("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)}
}
二、元組(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)
參考資料
- Martin Odersky . Scala 程式設計 (第 3 版)[M] . 電子工業出版社 . 2018-1-1
- 凱.S.霍斯特曼 . 快學 Scala(第 2 版)[M] . 電子工業出版社 . 2017-7