關於scala中的map基礎詳解

Scala提供了一套很好的集合實現，提供了一些集合類型的抽象。

Scala 集合分爲可變的和不可變的集合。

可變集合能夠在適當的地方被更新或擴展。這意味着你能夠修改，添加，移除一個集合的元素。

而不可變集合類，相比之下，永遠不會改變。不過，你仍然能夠模擬添加，移除或更新操做。可是這些操做將在每一種狀況下都返回一個新的集合，同時使原來的集合不發生改變。

Map(映射)是一種可迭代的鍵值對（key/value）結構。

全部的值均可以經過鍵來獲取。

Map 中的鍵都是惟一的。

Map 也叫哈希表（Hash tables）。

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

默認狀況下 Scala 使用不可變 Map。若是你須要使用可變集合，你須要顯式的引入 import scala.collection.mutable.Map 類

在 Scala 中 你能夠同時使用可變與不可變 Map，不可變的直接使用 Map，可變的使用 mutable.Map。如下實例演示了不可變 Map 的應用：

// 空哈希表，鍵爲字符串，值爲整型
var A:Map[Char,Int] = Map()

// Map 鍵值對演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

定義 Map 時，須要爲鍵值對定義類型。若是須要添加 key-value 對，可使用 + 號，以下所示：

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

Map 基本操做

Scala Map 有三個基本操做：

方法	描述
keys	返回 Map 全部的鍵(key)
values	返回 Map 全部的值(value)
isEmpty	在 Map 爲空時返回true

實例

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

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( "檢測 colors 是否爲空 : " + colors.isEmpty )
      println( "檢測 nums 是否爲空 : " + nums.isEmpty )
   }}

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

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

---

Map 合併

你可使用 ++ 運算符或 Map.++() 方法來鏈接兩個 Map，Map 合併時會移除重複的 key。如下演示了兩個 Map 合併的實例:

object Test {
   def main(args: Array[String]) {
      val colors1 = Map("red" -> "#FF0000",
                        "azure" -> "#F0FFFF",
                        "peru" -> "#CD853F")
      val colors2 = Map("blue" -> "#0033FF",
                        "yellow" -> "#FFFF00",
                        "red" -> "#FF0000")

      //  ++ 做爲運算符
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )

      //  ++ 做爲方法
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )

   }}

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

$ scalac Test.scala 
$ scala Testcolors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

---

輸出 Map 的 keys 和 values

如下經過 foreach 循環輸出 Map 中的 keys 和 values：

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) )}
   }}

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

$ scalac Test.scala 
$ scala TestKey = runoob Value = http://www.runoob.comKey = baidu Value = http://www.baidu.comKey = taobao Value = http://www.taobao.com

---

查看 Map 中是否存在指定的 Key

你可使用 Map.contains 方法來查看 Map 中是否存在指定的 Key。實例以下：

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")

      if( sites.contains( "runoob" )){
           println("runoob 鍵存在，對應的值爲 :"  + sites("runoob"))
      }else{
           println("runoob 鍵不存在")
      }
      if( sites.contains( "baidu" )){
           println("baidu 鍵存在，對應的值爲 :"  + sites("baidu"))
      }else{
           println("baidu 鍵不存在")
      }
      if( sites.contains( "google" )){
           println("google 鍵存在，對應的值爲 :"  + sites("google"))
      }else{
           println("google 鍵不存在")
      }
   }}

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

$ scalac Test.scala 
$ scala Testrunoob 鍵存在，對應的值爲 :http://www.runoob.combaidu 鍵存在，對應的值爲 :http://www.baidu.comgoogle 鍵不存在

---

Scala Map 方法

下表列出了 Scala Map 經常使用的方法：

序號	方法及描述
1	def ++(xs: Map[(A, B)]): Map[A, B] 返回一個新的 Map，新的 Map xs 組成
2	def -(elem1: A, elem2: A, elems: A*): Map[A, B] 返回一個新的 Map, 移除 key 爲 elem1, elem2 或其餘 elems。
3	def --(xs: GTO[A]): Map[A, B] 返回一個新的 Map, 移除 xs 對象中對應的 key
4	def get(key: A): Option[B] 返回指定 key 的值
5	def iterator: Iterator[(A, B)] 建立新的迭代器，並輸出 key/value 對
6	def addString(b: StringBuilder): StringBuilder 將 Map 中的全部元素附加到StringBuilder，可加入分隔符
7	def addString(b: StringBuilder, sep: String): StringBuilder 將 Map 中的全部元素附加到StringBuilder，可加入分隔符
8	def apply(key: A): B 返回指定鍵的值，若是不存在返回 Map 的默認方法
9	def clear(): Unit 清空 Map
10	def clone(): Map[A, B] 從一個 Map 複製到另外一個 Map
11	def contains(key: A): Boolean 若是 Map 中存在指定 key，返回 true，不然返回 false。
12	def copyToArray(xs: Array[(A, B)]): Unit 複製集合到數組
13	def count(p: ((A, B)) => Boolean): Int 計算知足指定條件的集合元素數量
14	def default(key: A): B 定義 Map 的默認值，在 key 不存在時返回。
15	def drop(n: Int): Map[A, B] 返回丟棄前n個元素新集合
16	def dropRight(n: Int): Map[A, B] 返回丟棄最後n個元素新集合
17	def dropWhile(p: ((A, B)) => Boolean): Map[A, B] 從左向右丟棄元素，直到條件p不成立
18	def empty: Map[A, B] 返回相同類型的空 Map
19	def equals(that: Any): Boolean 若是兩個 Map 相等(key/value 均相等)，返回true，不然返回false
20	def exists(p: ((A, B)) => Boolean): Boolean 判斷集合中指定條件的元素是否存在
21	def filter(p: ((A, B))=> Boolean): Map[A, B] 返回知足指定條件的全部集合
22	def filterKeys(p: (A) => Boolean): Map[A, B] 返回符合指定條件的不可變 Map
23	def find(p: ((A, B)) => Boolean): Option[(A, B)] 查找集合中知足指定條件的第一個元素
24	def foreach(f: ((A, B)) => Unit): Unit 將函數應用到集合的全部元素
25	def init: Map[A, B] 返回全部元素，除了最後一個
26	def isEmpty: Boolean 檢測 Map 是否爲空
27	def keys: Iterable[A] 返回全部的key/p>
28	def last: (A, B) 返回最後一個元素
29	def max: (A, B) 查找最大元素
30	def min: (A, B) 查找最小元素
31	def mkString: String 集合全部元素做爲字符串顯示
32	def product: (A, B) 返回集合中數字元素的積。
33	def remove(key: A): Option[B] 移除指定 key
34	def retain(p: (A, B) => Boolean): Map.this.type 若是符合知足條件的返回 true
35	def size: Int 返回 Map 元素的個數
36	def sum: (A, B) 返回集合中全部數字元素之和
37	def tail: Map[A, B] 返回一個集合中除了第一元素以外的其餘元素
38	def take(n: Int): Map[A, B] 返回前 n 個元素
39	def takeRight(n: Int): Map[A, B] 返回後 n 個元素
40	def takeWhile(p: ((A, B)) => Boolean): Map[A, B] 返回知足指定條件的元素
41	def toArray: Array[(A, B)] 集合轉數組
42	def toBuffer[B >: A]: Buffer[B] 返回緩衝區，包含了 Map 的全部元素
43	def toList: List[A] 返回 List，包含了 Map 的全部元素
44	def toSeq: Seq[A] 返回 Seq，包含了 Map 的全部元素
45	def toSet: Set[A] 返回 Set，包含了 Map 的全部元素
46	def toString(): String 返回字符串對象

更多方法能夠參考 API文檔