Scala學習筆記(八)(Set以及Map)

Scala集合為相同類型的配對的不同元素的集合。換句話說，集合是不包含重復元素的集合。有兩種集合，不可改變的和可變的。可變和不可變的對象之間的區別在於，當一個對象是不可變的，對象本身不能被改變。

默認情況下，Scala中使用不可變的集。如果想使用可變集，必須明確地導入scala.collection.mutable.Set類。如果想在同一個同時使用可變和不可變的集合，那么可以繼續參考不變的集合，但可以參考可變設為mutable.Set。以下是聲明不變集合示例：

// Empty set of integer type var s : Set[Int] = Set() // Set of integer type var s : Set[Int] = Set(1,3,5,7) or var s = Set(1,3,5,7)

在定義空集，類型注釋是必要的，因為系統需要指定一個具體的類型變量。

集合基本操作：

集合所有操作可以體現在以下三個方法：

方法	描述
head	此方法返回集合的第一個元素。
tail	該方法返回集合由除第一個以外的所有元素。
isEmpty	如果設置為空，此方法返回true，否則為false。

以下是上述方法中的例子顯示的用法：

object Test { def main(args: Array[String]) { val fruit = Set("apples", "oranges", "pears") val nums: Set[Int] = Set() println( "Head of fruit : " + fruit.head ) println( "Tail of fruit : " + fruit.tail ) println( "Check if fruit is empty : " + fruit.isEmpty ) println( "Check if nums is empty : " + nums.isEmpty ) } }

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala C:/>scala Test Head of fruit : apples Tail of fruit : Set(oranges, pears) Check if fruit is empty : false Check if nums is empty : true

 

串聯集合：

可以使用++運算符或集。++()方法來連接兩個或多個集，但同時增加了集它會刪除重復的元素。以下是這個例子來連接兩個集合：

object Test { def main(args: Array[String]) { val fruit1 = Set("apples", "oranges", "pears") val fruit2 = Set("mangoes", "banana") // use two or more sets with ++ as operator var fruit = fruit1 ++ fruit2 println( "fruit1 ++ fruit2 : " + fruit ) // use two sets with ++ as method fruit = fruit1.++(fruit2) println( "fruit1.++(fruit2) : " + fruit ) } }

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala C:/>scala Test fruit1 ++ fruit2 : Set(banana, apples, mangoes, pears, oranges) fruit1.++(fruit2) : Set(banana, apples, mangoes, pears, oranges) C:/>

查找集合中最大，最小的元素：

可以使用Set.min方法找出最小元素，Set.max方法找出一組可用最大元素。以下為例子來說明的用法：

object Test { def main(args: Array[String]) { val num = Set(5,6,9,20,30,45) // find min and max of the elements println( "Min element in Set(5,6,9,20,30,45) : " + num.min ) println( "Max element in Set(5,6,9,20,30,45) : " + num.max ) } }

讓我們編譯和運行上面的程序，這將產生以下結果：

C:/>scalac Test.scala C:/>scala Test Min element in Set(5,6,9,20,30,45) : 5 Max element in Set(5,6,9,20,30,45) : 45 C:/>

查找集合的共同值：

可以使用Set.&方法或Set.intersect方法找出兩個集合之間的共同值。以下的例子來說明的用法：

bject Test { def main(args: Array[String]) { val num1 = Set(5,6,9,20,30,45) val num2 = Set(50,60,9,20,35,55) // find common elements between two sets println( "num1.&(num2) : " + num1.&(num2) ) println( "num1.intersect(num2) : " + num1.intersect(num2) ) } }

讓我們編譯和運行上面的程序，這將產生以下結果：

C:/>scalac Test.scala C:/>scala Test num1.&(num2) : Set(20, 9) num1.intersect(num2) : Set(20, 9) C:/>

Scala集合方法：

以下是可以同時使用集合的重要方法。有關可用方法的完整列表，請Scala官方文檔。

 

SN	方法及描述
1	def +(elem: A): Set[A] 創建一組新的具有附加元件，除非該元件已經存在
2	def -(elem: A): Set[A] 創建一個新的從這個集合中刪除一個給定的元素
3	def contains(elem: A): Boolean 如果elem包含在這個集合返回true，否則為false。
4	def &(that: Set[A]): Set[A] 返回新的集合組成在這個集合，並在給定的集合，所有的元素。
5	def &~(that: Set[A]): Set[A] 返回此集合和另一個集合的差異
6	def +(elem1: A, elem2: A, elems: A*): Set[A] 創建一個新的不可變的集合與來自傳遞集合額外的元素
7	def ++(elems: A): Set[A] 連接此不可變的集合使用另一個集合到這個不可變的集合的元素。
8	def -(elem1: A, elem2: A, elems: A*): Set[A] 返回包含當前不可變的集合，除了每一個給定參數的元素之一，較少出現的所有元素的不可變的集合。
9	def addString(b: StringBuilder): StringBuilder 這追加不可變的集到一個字符串生成器的所有元素。
10	def addString(b: StringBuilder, sep: String): StringBuilder 這追加不可變的集合使用分隔字符串一個字符串生成器的所有元素。
11	def apply(elem: A) 測試如果一些元素被包含在這個集合。
12	def count(p: (A) => Boolean): Int 計算在不可變的集合滿足謂詞的元素數。
13	def copyToArray(xs: Array[A], start: Int, len: Int): Unit 這種不可變的集合到一個數組的副本元素。
14	def diff(that: Set[A]): Set[A] 計算這組和另一組的差異。
15	def drop(n: Int): Set[A]] 返回除了第n個的所有元素。
16	def dropRight(n: Int): Set[A] 返回除了最后的n個的所有元素。
17	def dropWhile(p: (A) => Boolean): Set[A] 丟棄滿足謂詞的元素最長前綴。
18	def equals(that: Any): Boolean equals方法的任意序列。比較該序列到某些其他對象。
19	def exists(p: (A) => Boolean): Boolean 測試謂詞是否持有一些這種不可變的集合的元素。
20	def filter(p: (A) => Boolean): Set[A] 返回此不可變的集合滿足謂詞的所有元素。
21	def find(p: (A) => Boolean): Option[A] 找到不可變的集合滿足謂詞，如有第一個元素
22	def forall(p: (A) => Boolean): Boolean 測試謂詞是否持有這種不可變的集合中的所有元素。
23	def foreach(f: (A) => Unit): Unit 應用一個函數f這個不可變的集合中的所有元素。
24	def head: A 返回此不可變的集合的第一個元素。
25	def init: Set[A] 返回除了最后的所有元素。
26	def intersect(that: Set[A]): Set[A] 計算此set和另一組set之間的交叉點。
27	def isEmpty: Boolean 測試此集合是否為空。
28	def iterator: Iterator[A] 創建一個新的迭代器中包含的可迭代對象中的所有元素。
29	def last: A 返回最后一個元素。
30	def map[B](f: (A) => B): immutable.Set[B] 通過應用函數這一不可變的集合中的所有元素構建一個新的集合。
31	def max: A 查找最大的元素。
32	def min: A 查找最小元素。
33	def mkString: String 顯示此不可變的集合字符串中的所有元素。
34	def mkString(sep: String): String 顯示此不可變的集合在一個字符串使用分隔字符串的所有元素。
35	def product: A 返回此不可變的集合相對於*操作在num的所有元素的產物。
36	def size: Int 返回此不可變的集合元素的數量。
37	def splitAt(n: Int): (Set[A], Set[A]) 返回一對不可變的集合組成這個不可變的集的前n個元素，以及其他元素。
38	def subsetOf(that: Set[A]): Boolean 返回true，如果此set就是一個子集，也就是說，如果這集合的每個元素也是一個元素。
39	def sum: A 返回此不可變的集合的所有元素的總和使用對於+運算符在num。
40	def tail: Set[A] 返回一個不可變的集合組成這個不可變的集合的所有元素，除了第一個。
41	def take(n: Int): Set[A] 返回前n個元素。
42	def takeRight(n: Int):Set[A] 返回最后n個元素。
43	def toArray: Array[A] 返回一個包含此不可變的集合的所有元素的數組。
44	def toBuffer[B >: A]: Buffer[B] 返回一個包含此不可變的集合中的所有元素的緩沖區。
45	def toList: List[A] 返回一個包含此不可變的集合中的所有元素的列表。
46	def toMap[T, U]: Map[T, U] 這種不可變的集合轉換為映射
47	def toSeq: Seq[A] 返回一個包含此不可變的集的所有元素的序列。
48	def toString(): String 返回對象的字符串表示。

 

 

 

 

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Scala Map[K, V]

Scala中的映射是鍵/值對的集合。任何值可以根據它的鍵進行檢索。鍵是在映射唯一的，但值不一定是唯一的。映射也被稱為哈希表。有兩種類型的映射，不可變以及可變的。可變和不可變的對象之間的區別在於，當一個對象是不可變的，對象本身不能被改變。

默認情況下，Scala中使用不可變的映射。如果想使用可變集，必須明確地導入scala.collection.mutable.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)

映射的基本操作：

在映射上的所有操作可被表示在下面的三種方法：

方法	描述
keys	這個方法返回一個包含映射中的每個鍵的迭代。
values	這個方法返回一個包含映射中的每個值的迭代。
isEmpty	如果映射為空此方法返回true，否則為false。

以下是上述方法中的例子顯示的用法：

object Test { 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 ) } }

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala C:/>scala Test 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 C:/>

串聯映射

可以使用++運算符或映射。++()方法來連接兩個或更多的映射，但同時增加了映射，將刪除重復的鍵。下面是一個例子來連接兩個映射：

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

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala C:/>scala Test 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) C:/>

打印映射的鍵和值：

可以通過使用foreach循環重復Map的鍵和值。以下為例子來說明的用法：

object Test { 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) )} } }

在這里，我們使用迭代器相關的foreach遍歷鍵方法。當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala C:/>scala Test Key = red Value = #FF0000 Key = azure Value = #F0FFFF Key = peru Value = #CD853F C:/>

檢查映射中的鍵：

可以使用 Map.contains 方法來測試，如果給定的鍵存在於映射或沒有。以下為例子來說明的用法：

bject Test { 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") } } }

當上述代碼被編譯和執行時，它產生了以下結果：

C:/>scalac Test.scala C:/>scala Test Red key exists with value :#FF0000 Maroon key does not exist C:/>

Scala映射的方法：

以下是可以使用映射的重要方法。有關可用方法的完整列表，請Scala的官方文件。

SN	方法及描述
1	def ++(xs: Map[(A, B)]): Map[A, B] 返回包含此映射的映射和那些xs提供了一個新的映射。
2	def -(elem1: A, elem2: A, elems: A*): Map[A, B] 返回包含除具有一個鍵等於映射elem1，elem2時或任何元素此映射的所有映射的新映射。
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 返回true如果給定的斷言p成立了一些這方面可收縮集合的元素，否則為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 返回對象的字符串表示