【導讀：數據是二十一世紀的石油，蘊含巨大價值，這是·情報通·大數據技術系列第[89]篇文章，歡迎閱讀和收藏】

1 基本概念

映射 是一種把鍵對象和值對象映射的集合，它的每一個元素都包含一對鍵對象和值對象。

元組 是不同類型的值的集合。

2 術語解釋

2.1 Map （ 映射 ）

映射是一種可迭代的鍵值對（ key/value ）結構。所有的值都可以通過鍵來獲取。

Map 中的鍵都是唯一的。

Map 也叫哈希表（ Hash tables ）。

Map 有兩種類型，可變與不可變，區別在於可變對象可以修改它，而不可變對象不可以。

默認情況下 Scala 使用不可變 Map 。如果你需要使用可變集合，你需要顯式的引入 import scala.collection.mutable.Map 類

2.2 元祖

與列表一樣，元組也是不可變的，但與列表不同的是元組可以包含不同類型的元素。

3 詳細說明

3.1 Map （映射）

3.1.1 Map 基本操作

Scala Map 有三個基本操作 ：

實例

以下實例演示了以上三個方法的基本應用：

<code>object Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "azure" -> "#F0FFFF",
                       "peru" -> "#CD853F")
      val nums: Map[Int, Int] = Map()
      println( "colors 中的鍵為 : " + colors.keys )
      println( "colors 中的值為 : " + colors.values )
      println( "檢測 nums 是否為空 : " + nums.isEmpty )   
\t\t}
}/<code>

執行以上代碼，輸出結果為 ：

<code>$ scalac Test.scala 
$ scala Test
colors 中的鍵為 : Set(red, azure, peru)
colors 中的值為 : MapLike(#FF0000, #F0FFFF, #CD853F)
檢測 colors 是否為空 : false
檢測 nums 是否為空 : true/<code>

3.1.2 輸出 Map 的 keys 和 values

以下通過 foreach 循環輸出 Map 中的 keys 和 values ：

<code>object Test {
   def main(args: Array[String]) {
      val sites = Map("runoob" -> "http://www.runoob.com",
                       "baidu" -> "http://www.baidu.com",
                       "taobao" -> "http://www.taobao.com")
      sites.keys.foreach{ i =>  
                           print( "Key = " + i )
                           println(" Value = " + sites(i) )}
   }
}/<code>

執行以上代碼，輸出結果為 ：

<code>$ scalac Test.scala 
$ scala Test
Key = runoob Value = http://www.runoob.com
Key = baidu Value = http://www.baidu.com
Key = taobao Value = http://www.taobao.com/<code>

3.2 元組

3.2.1 元祖的值

元祖的值是通過將單個的值包含在圓括號中構成的。例如：

<code>val t = (1, 3.14, "Fred")  /<code>

以上實例在元組中定義了三個元素，對應的類型分別為 [Int, Double, java.lang.String] 。

此外我們也可以使用以上方式來定義：

<code>val t = new Tuple3(1, 3.14, "Fred")/<code>

元組的實際類型取決於它的元素的類型，比如 (99, "runoob") 是 Tuple2[Int, String] 。 ('u', 'r', "the", 1, 4, "me") 為 Tuple6[Char, Char, String, Int, Int, String] 。

目前 Scala 支持的元組最大長度為 22 。對於更大長度你可以使用集合，或者擴展元組。

訪問元組的元素可以通過數字索引，如下一個元組：

<code>val t = (4,3,2,1)/<code>

我們可以使用 t._1 訪問第一個元素， t._2 訪問第二個元素，如下所示 ：

<code>object Test {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      val sum = t._1 + t._2 + t._3 + t._4
      println( "元素之和為: "  + sum )
   }
}/<code>

執行以上代碼，輸出結果為：

<code>$ scalac Test.scala 
$ scala Test
元素之和為: 10/<code>

3.2.2 迭代元 組

你可以使用 Tuple.productIterator() 方法來迭代輸出元組的所有元素 ：

<code>object Test {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }
}/<code>

執行以上代碼，輸出結果為 ：

<code>$ scalac Test.scala 
$ scala Test
Value = 4
Value = 3
Value = 2
Value = 1/<code>

閱讀更多 情報通 的文章

關鍵字: 百度 八十九 元組