摘要:

一個經典的程式設計師名言是：＂如果只能有一種資料結構，那就用雜湊表吧＂。雜湊表或者更籠統地說對映，是最靈活多變的資料結構之一。對映是鍵／值對偶的集合。Scala有一個通用的叫法：元組，即n個物件的聚集，並不一定要相同型別的。對偶不過是一個 n=2的元組，元組對於那種需要將兩個或更多值聚集在一起時特別有用。本篇的要點包括：

01. Scala有十分易用的語法來建立、查詢和遍歷對映。

02. 你需要從可變的和不可變的對映中做出選擇。

03. 預設情況下，你得到的是一個雜湊對映，不過你也可以指明要樹形對映。

04. 你可以很容易地在Scala對映和Java對映之間來回切換。

05. 元組可以用來聚集值。

不可變對映

我們可以這樣構造一個對映:

val scores = Map ("Alice"-> 10, "Bob"->3, "Cindy"->8)

上述程式碼構造出一個不可變的Map[String，Int]，其值不能被改變。

可變對映

如果你想要一個可變對映，則用

val scores = scala.collection.mutable.Map("Alice"-> 10, "Bob"->3, "Cindy"->8)

如果想從—個空的對映開始，你需要選定一個對映實現並給出型別引數：

val scores = new scala.collection.mutable.HashMap [String, Int]

在Scala中，對映是對偶的集合。對偶簡單地說就是兩個值構成的組，這兩個值並不一定是同一個型別的，比如("Alice"，10)

操作符建立對偶

操作符用來建立對偶：

"Alice"->10

上述程式碼產出的值是：

("Alice", 10)

完全也可以用下面這種方式來定義對映：

val scores=Map ( ("Alice", 10), ("Bob", 3), ("Cindy", 8) )

只不過->操作符看上去比圓括號更易讀那麼一點，也更加符合大家對對映的直觀感覺：對映這種資料結構是一種將鍵對映到值的函式。區別在於通常的函式計算值，而對映只是做查詢。

在Scala中，函式和對映之間的相似性尤為明顯，因為你將使用()

val bobsScore = scores ("Bob") //類似於Java中的scores．get ("Bob")

如果對映並不包含請求中使用的鍵，則會丟擲異常。要檢查對映中是否有某個指定的鍵，可以用contains方法：

val bobsScore = if (scores.contains ("Bob")) scores("Bob") else 0

由於這樣的組合呼叫十分普遍，以下是一個快捷寫法：

val bobsScore = scores.getOrElse("Bob", 0) // 如果對映包含鍵"Bob"，返回對應的值；否則，返回0

最後，對映.get(鍵)這樣的呼叫返回一個Option物件，要麼是Some（鍵對應的值），要麼是None

更新可變對映

在可變對映中，你可以更新某個對映的值，或者新增一個新的對映關係，做法是在=號的左側使用()：

scores ("Bob") = 10 // 更新鍵"Bob"對應的值

scores ("Fred")=7 // 增加新的鍵／值對偶到scores

或者，你也可以用+=操作來新增多個關係：

scores+= ("Bob"-> 10, "Fred"->7)

要移除某個鍵和對應的值，使用-=操作符：

scores -= "Alice"

不可變對映

雖然不能更新一個不可變的對映，但你可以做一些同樣有用的操作，即獲取一個包含所需要的更新的新對映：

val newScores = scores+ ("Bob"->10，"Fred"->7) // 更新過的新對映

newScores對映包含了與scores相同的對映關係，此外"Bob"被更新，"Fred"被添加了進來

除了把結果作為新值儲存外，你也可以更新Var變數：

var scores = …

scores = scores+ ("Bob"->10, "Fred"->7)

同理，要從不可變對映中移除某個鍵，你可以用一操作符來獲取一個新的去掉該鍵的對映：

scores = scores - "Alice"

你可能會覺得這樣不停地建立新對映效率很低，不過事實並非如此。老的和新的對映共享大部分結構。這樣做之所以可行，是因為它們是不可變的。

如下這段超簡單的迴圈即可遍歷對映中所有的鍵／值對偶：

for ((k，v) <- 對映) 處理k和v

這裡的"魔法"是你可以在Scala的for迴圈中使用模式匹配。這樣一來，不需要冗雜的方法呼叫，你就可以得到每一個對偶的鍵和值

如果出於某種原因，你只需要訪問鍵或值，像Java一樣，則可以用keySet和values方法。values方法返回—個Iterable，你可以在for迴圈當中使用這個Iterable

scores.keySet // 一個類似Set（"Bob"，"Cindy"，"Fred"，"Alice"）這樣的集合

for ( v <- scores.values) printlnI(v) // 將列印10 8 7 10或其他排列組合

要反轉一個對映，即交換鍵和值的位置，可以用：

for ( (k，v) <- 對映) yield (v.k）

在操作對映時，你需要選定一個實現：一個雜湊表或者一個平衡樹。預設情況下，Scala給的是雜湊表。由於對使用的鍵沒有很好的雜湊函式，或者需要順序地訪問所有的鍵，因此，你可能會想要一個樹形對映。

要得到一個不可變的樹形對映而不是雜湊對映的話，可以用：

val scores = scala.collections.immutable.SortedMap("Alice"->10，"Fred"->7， "Bob"->3，"Cindy"->8)

很可惜，Scala( 2.9)並沒有可變的樹形對映。如果那是你要的，最接近的選擇是使用Java的TreeMap。需要注意的是：如果要按插入順序訪問所有鍵，使用LinkedHashMap，例如：

val months = scala.collection.mutable.LinkedHashMap("January" -> 1,"February" -> 2， "March" -> 3， …)

Java到Scala

如果你通過Java方法呼叫得到了一個Java對映，你可能想要把它轉換成一個Scala對映，以便使用更便捷的Scala對映API。這對於需要操作Scala，並未提供的可變樹形對映的情況也很有用。只需要增加如下引入語句：

import scala.collection.JavaConversions .mapAsScalaMap

然後通過指定Scala對映類型來觸發轉換：

val scores:scala.collection.mutable.Map[String, Int]=new java.util.TreeMap[String, Int]

除此之外，你還可以得到從java.util.Properties到Map[String，String]的轉換：

import scala.collection.JavaConversions.propertiesAsScalaMap

val props:Scala.collection.Map[String, String] = System.getProperties()

Scala到Java

反過來講，要把Scala對映傳遞給預期Java對映的方法，提供相反的隱式轉換即可

例如：

import scala.collection.JavaConversions.mapAsjavaMap

import java.awt.font.TextAttribute. _ // 引入下面的對映會用到的鍵

val attrs = Map ( FAMILY -> "Serif"， SIZE -> 12 ) // Scala對映

val font=new java.awt.Font (attrs) // 該方法預期一個Java對映

元組定義

對映是鍵／值對偶的集合。對偶足元組( tuple)的最簡單形態，元組是不同型別的值的聚集。元組的值是通過將單個的值包含在圓括號中構成的。例如：

(1, 3.14, "Fred")

是一個元組，型別為：

Tuple3 [Int, Double, java.lang.String]

型別定義也可以寫為：

(Int, Double, java,lang.String)

如果你有一個元組，比如：

val t = (1,3.14, "Fred")

你就可以用方法_1、_2、_3訪問其組元，比如：

val second = t._2 // 將second設為3.14

需要注意的是：和陣列或字串中的位置不同，元組的各組元從1開始，而不是0。你可以把t._2寫為t _2，即用空格而不是句點，但不能寫成t_2

獲取元組

通常，使用模式匹配來獲取元組的組元，例如：

val (first，second，third)=t //將first設為1，second設為3.14．third設為"Fred"

如果並不是所有的部件都需要，那麼可以在不需要的部件位置上使用_：

val (first, second, _ ) = t

元組可以用於函式需要返回不止一個值的情況。舉例來說，StringOps的partition方法返回的是一對字串，分別包含了滿足某個條件和不滿足該條件的字元：

"New York".partition ( _.isUpper) //輸出對偶( "NY"，"ew ork")

使用元組的原因之一是把多個值綁在一起，以便它們能夠被一起處理，這通常可以用zip方法來完成。舉例來說，下面的程式碼：

val symbols = Array ("<"，"-"，">")

val counts = Array (2, 10, 2)

val pairs = symbols.zip(counts)

輸出對偶的陣列：

Array ( ("<",2)，("-",10), (">",2) )

然後這些對偶就可以被一起處理：

for ( (s,n) <- pairs ) Console.print(s*n) // 會列印<<---------->>

需要注意的是：用toMap方法可以將對偶的集合轉換成對映。如果你有一個鍵的集合，以及一個與之平行對應的值的集合，那麼你就可以用拉鍊操作將它們組合成一個對映：keys.zip(values) .toMap