【导读：数据是二十一世纪的石油，蕴含巨大价值，这是·情报通·大数据技术系列第[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>

閱讀更多 情報通 的文章

關鍵字: 元组 淘宝网 八十九