Scala - 對映



Scala 對映是鍵/值對的集合。任何值都可以根據其鍵檢索。鍵在對映中是唯一的,但值不必唯一。對映也稱為雜湊表。對映有兩種,**不可變**和**可變**。可變物件和不可變物件的區別在於,當物件不可變時,物件本身不能更改。

預設情況下,Scala 使用不可變對映。如果要使用可變對映,則必須顯式匯入 **scala.collection.mutable.Map** 類。如果要在同一個中使用可變和不可變對映,則可以繼續將不可變對映稱為 **Map**,但可以將可變集合稱為 **mutable.Map**。

以下是宣告不可變對映的示例語句:

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

在定義空對映時,型別註釋是必要的,因為系統需要為變數分配一個具體的型別。如果要向對映新增鍵值對,可以使用運算子 +,如下所示。

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

對映的基本操作

對映上的所有操作都可以用以下三種方法表示。

序號 方法和描述
1

keys

此方法返回一個包含對映中每個鍵的可迭代物件。

2

values

此方法返回一個包含對映中每個值的可迭代物件。

3

isEmpty

如果對映為空,則此方法返回 true,否則返回 false。

嘗試以下示例程式,該程式顯示了對映方法的使用。

示例

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

      val nums: Map[Int, Int] = Map()

      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
      println( "Check if colors is empty : " + colors.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

將上述程式儲存在 **Demo.scala** 中。以下命令用於編譯和執行此程式。

命令

\>scalac Demo.scala
\>scala Demo

輸出

Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

連線對映

可以使用 **++** 運算子或 **Map.++()** 方法連線兩個或多個對映,但在新增對映時,它將刪除重複的鍵。

嘗試以下示例程式來連線兩個對映。

示例

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

      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )

      // use two maps with ++ as method
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )
   }
}

將上述程式儲存在 **Demo.scala** 中。以下命令用於編譯和執行此程式。

命令

\>scalac Demo.scala
\>scala Demo

輸出

colors1 ++ 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)

從對映中列印鍵和值

可以使用“foreach”迴圈遍歷對映的鍵和值。在這裡,我們使用與迭代器關聯的方法 **foreach** 來遍歷鍵。以下是示例程式。

示例

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF","peru" -> "#CD853F")

      colors.keys.foreach{ i =>  
         print( "Key = " + i )
         println(" Value = " + colors(i) )}
   }
}

將上述程式儲存在 **Demo.scala** 中。以下命令用於編譯和執行此程式。

命令

\>scalac Demo.scala
\>scala Demo

輸出

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F

檢查對映中的鍵

可以使用 **Map.contains** 方法來測試給定鍵是否存在於對映中。嘗試以下示例程式來進行鍵檢查。

示例

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

      if( colors.contains( "red" )) {
         println("Red key exists with value :"  + colors("red"))
      } else {
           println("Red key does not exist")
      }
      
      if( colors.contains( "maroon" )) {
         println("Maroon key exists with value :"  + colors("maroon"))
      } else {
         println("Maroon key does not exist")
      }
   }
}

將上述程式儲存在 **Demo.scala** 中。以下命令用於編譯和執行此程式。

命令

\>scalac Demo.scala
\>scala Demo

輸出

Red key exists with value :#FF0000
Maroon key does not exist

Scala 對映方法

以下是在使用對映時可以使用的重要方法。有關可用方法的完整列表,請檢視 Scala 的官方文件。

序號 帶描述的方法
1

def ++(xs: Map[(A, B)]): Map[A, B]

返回一個新對映,其中包含此對映的對映和 xs 提供的對映。

2

def -(elem1: A, elem2: A, elems: A*): Map[A, B]

返回一個新對映,其中包含此對映的所有對映,但鍵等於 elem1、elem2 或任何 elems 的對映除外。

3

def --(xs: GTO[A]): Map[A, B]

返回一個新對映,其中包含此對映的所有鍵/值對映,但鍵等於可遍歷物件 xs 中的鍵的對映除外。

4

def get(key: A): Option[B]

可選地返回與鍵關聯的值。

5

def iterator: Iterator[(A, B)]

建立一個新的迭代器,遍歷此對映的所有鍵/值對

6

def addString(b: StringBuilder): StringBuilder

將此可收縮集合的所有元素附加到字串生成器。

7

def addString(b: StringBuilder, sep: String): StringBuilder

使用分隔符字串將此可收縮集合的所有元素附加到字串生成器。

8

def apply(key: A): B

返回與給定鍵關聯的值,或者如果不存在,則返回對映的預設方法的結果。

9

def clear(): Unit

從對映中刪除所有繫結。此操作完成後,對映將為空。

10

def clone(): Map[A, B]

建立接收器物件的副本。

11

def contains(key: A): Boolean

如果此對映中存在鍵的繫結,則返回 true,否則返回 false。

12

def copyToArray(xs: Array[(A, B)]): Unit

將此可收縮集合的值複製到陣列。用此可收縮集合的值填充給定的陣列 xs。

13

def count(p: ((A, B)) => Boolean): Int

計算可收縮集合中滿足謂詞的元素數量。

14

def default(key: A): B

定義對映的預設值計算,在找不到鍵時返回。

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]

刪除滿足謂詞的最長字首元素。

18

def empty: Map[A, B]

返回相同型別的空對映。

19

def equals(that: Any): Boolean

如果兩個對映都包含完全相同的鍵/值,則返回 true,否則返回 false。

20

def exists(p: ((A, B)) => Boolean): Boolean

如果給定的謂詞 p 對此可收縮集合的某些元素成立,則返回 true,否則返回 false。

21

def filter(p: ((A, B))=> Boolean): Map[A, B]

返回此可收縮集合中滿足謂詞的所有元素。

22

def filterKeys(p: (A) => Boolean): Map[A, B]

返回一個不可變對映,該對映僅包含此對映中鍵滿足謂詞 p 的鍵值對。

23

def find(p: ((A, B)) => Boolean): Option[(A, B)]

查詢可收縮集合中滿足謂詞的第一個元素(如果有)。

24

def foreach(f: ((A, B)) => Unit): Unit

將函式 f 應用於此可收縮集合的所有元素。

25

def init: Map[A, B]

返回除最後一個元素之外的所有元素。

26

def isEmpty: Boolean

測試對映是否為空。

27

def keys: Iterable[A]

返回所有鍵上的迭代器。

28

def last: (A, B)

返回最後一個元素。

29

def max: (A, B)

查詢最大元素。

30

def min: (A, B)

查詢最小元素。

31

def mkString: String

在字串中顯示此可收縮集合的所有元素。

32

def product: (A, B)

返回此可收縮集合中所有元素相對於 num 中的 * 運算子的乘積。

33

def remove(key: A): Option[B]

從此對映中刪除一個鍵,將以前與該鍵關聯的值作為選項返回。

34

def retain(p: (A, B) => Boolean): Map.this.type

僅保留謂詞 p 返回 true 的對映。

35

def size: Int

返回此對映中的元素數量。

36

def sum: (A, B)

返回此可收縮集合中所有元素相對於 num 中的 + 運算子的和。

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]

返回一個緩衝區,其中包含此對映的所有元素。

43

def toList: List[A]

返回一個列表,其中包含此對映的所有元素。

44

def toSeq: Seq[A]

返回一個序列,其中包含此對映的所有元素。

45

def toSet: Set[A]

返回一個集合,其中包含此對映的所有元素。

46

def toString(): String

返回物件的字串表示形式。

scala_collections.htm
廣告