一、前述
Scala在常用的集合的類別有數組，List，Set，Map，元祖。
二、具體實現
數組
1、創建數組
- new Array[Int](10)
賦值：arr(0) = xxx
Array[String](“s1”,”s2”,”s3”)
/**
* 創建數組兩種方式：
* 1.new Array[String](3)
* 2.直接Array
*/
//創建類型為Int 長度為3的數組
val arr1 = new Array[Int](3)
//創建String 類型的數組，直接賦值
val arr2 = Array[String]("s100","s200","s300")
//賦值
arr1(0) = 100
arr1(1) = 200
arr1(2) = 300
2、數組遍歷
/**
* 遍歷兩種方式
*/
for(i <- arr1){
println(i)
}
arr1.foreach(i => {
println(i)
})
for(s <- arr2){
println(s)
}
arr2.foreach {
x => println(x)
}
創建二維數組（相當於數組中的每元素是一個數組）
/**
* 創建二維數組和遍歷
*/
val arr3 = new Array[Array[String]](3)
arr3(0)=Array("1","2","3")
arr3(1)=Array("4","5","6")
arr3(2)=Array("7","8","9")
for(i <- 0 until arr3.length){
for(j <- 0 until arr3(i).length){
print(arr3(i)(j)+" ")
}
println()
}
var count = 0
for(arr <- arr3 ;i <- arr){
if(count%3 == 0){
println()
}
print(i+" ")
count +=1
}
arr3.foreach { arr => {
arr.foreach { println }
}}
val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
arr4.foreach { arr => {
arr.foreach(i => {
println(i)
})
}}
println("-------")
for(arr <- arr4;i <- arr){
println(i)
}
備注：數組方法
1
def apply( x: T, xs: T* ): Array[T]
創建指定對象 T 的數組, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2
def concat[T]( xss: Array[T]* ): Array[T]
合並數組
3
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
復制一個數組到另一個數組上。相等於 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
4
def empty[T]: Array[T]
返回長度為 0 的數組
5
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回指定長度數組，每個數組元素為指定函數的返回值。
以上實例數組初始值為 0，長度為 3，計算函數為a=>a+1：
scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
6
def fill[T]( n: Int )(elem: => T): Array[T]
返回數組，長度為第一個參數指定，同時每個元素使用第二個參數進行填充。
7
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
返回二數組，長度為第一個參數指定，同時每個元素使用第二個參數進行填充。
8
def ofDim[T]( n1: Int ): Array[T]
創建指定長度的數組
9
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
創建二維數組
10
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
創建三維數組
11
def range( start: Int, end: Int, step: Int ): Array[Int]
創建指定區間內的數組，step 為每個元素間的步長
12
def range( start: Int, end: Int ): Array[Int]
創建指定區間內的數組
13
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
返回指定長度數組，每個數組元素為指定函數的返回值，默認從 0 開始。
以上實例返回 3 個元素：
scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
14
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
返回指定長度的二維數組，每個數組元素為指定函數的返回值，默認從 0 開始。
15
Array.concate：合並數組
16
Array.fill(5)(“bjsxt”)：創建初始值的定長數組
list集合
1、創建list
val list = List(1,2,3,4)
Nil長度為0的list
//創建
val list = List(1,2,3,4,5)
//遍歷
list.foreach { x => println(x)}
// list.foreach { println}
//filter
val list1 = list.filter { x => x>3 }
list1.foreach { println}
//count
val value = list1.count { x => x>3 }
println(value)
//map
val nameList = List(
"hello bjsxt",
"hello xasxt",
"hello shsxt"
)
val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
mapResult.foreach{println}
//flatmap
val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
flatMapResult.foreach { println }
備注：List方法總結
1 def +(elem: A): List[A]
前置一個元素列表
2 def ::(x: A): List[A]
在這個列表的開頭添加的元素。
3 def :::(prefix: List[A]): List[A]
增加了一個給定列表中該列表前面的元素。
4 def ::(x: A): List[A]
增加了一個元素x在列表的開頭
5 def addString(b: StringBuilder): StringBuilder
追加列表的一個字符串生成器的所有元素。
6 def addString(b: StringBuilder, sep: String): StringBuilder
追加列表的使用分隔字符串一個字符串生成器的所有元素。
7 def apply(n: Int): A
選擇通過其在列表中索引的元素
8 def contains(elem: Any): Boolean
測試該列表中是否包含一個給定值作為元素。
9 def copyToArray(xs: Array[A], start: Int, len: Int): Unit
列表的副本元件陣列。填充給定的數組xs與此列表中最多len個元素，在位置開始。
10 def distinct: List[A]
建立從列表中沒有任何重復的元素的新列表。
11 def drop(n: Int): List[A]
返回除了第n個的所有元素。
12 def dropRight(n: Int): List[A]
返回除了最后的n個的元素
13 def dropWhile(p: (A) => Boolean): List[A]
丟棄滿足謂詞的元素最長前綴。
14 def endsWith[B](that: Seq[B]): Boolean
測試列表是否使用給定序列結束。
15 def equals(that: Any): Boolean
equals方法的任意序列。比較該序列到某些其他對象。
16 def exists(p: (A) => Boolean): Boolean
測試謂詞是否持有一些列表的元素。
17 def filter(p: (A) => Boolean): List[A]
返回列表滿足謂詞的所有元素。
18 def forall(p: (A) => Boolean): Boolean
測試謂詞是否持有該列表中的所有元素。
19 def foreach(f: (A) => Unit): Unit
應用一個函數f以列表的所有元素。
20 def head: A
選擇列表的第一個元素
21 def indexOf(elem: A, from: Int): Int
經過或在某些起始索引查找列表中的一些值第一次出現的索引。
22 def init: List[A]
返回除了最后的所有元素
23 def intersect(that: Seq[A]): List[A]
計算列表和另一序列之間的多重集交集。
24 def isEmpty: Boolean
測試列表是否為空
25 def iterator: Iterator[A]
創建一個新的迭代器中包含的可迭代對象中的所有元素
26 def last: A
返回最后一個元素
27 def lastIndexOf(elem: A, end: Int): Int
之前或在一個給定的最終指數查找的列表中的一些值最后一次出現的索引
28 def length: Int
返回列表的長度
29 def map[B](f: (A) => B): List[B]
通過應用函數以g這個列表中的所有元素構建一個新的集合
30 def max: A
查找最大的元素
31 def min: A
查找最小元素
32 def mkString: String
顯示列表的字符串中的所有元素
33 def mkString(sep: String): String
顯示的列表中的字符串中使用分隔串的所有元素
34 def reverse: List[A]
返回新列表，在相反的順序元素
35 def sorted[B >: A]: List[A]
根據排序對列表進行排序
36 def startsWith[B](that: Seq[B], offset: Int): Boolean
測試該列表中是否包含給定的索引處的給定的序列
37 def sum: A
概括這個集合的元素
38 def tail: List[A]
返回除了第一的所有元素
39 def take(n: Int): List[A]
返回前n個元素
40 def takeRight(n: Int): List[A]
返回最后n個元素
41 def toArray: Array[A]
列表以一個數組變換
42 def toBuffer[B >: A]: Buffer[B]
列表以一個可變緩沖器轉換
43 def toMap[T, U]: Map[T, U]
此列表的映射轉換
44 def toSeq: Seq[A]
列表的序列轉換
45 def toSet[B >: A]: Set[B]
列表到集合變換
46 def toString(): String
列表轉換為字符串
常用方法：
- filter:過濾元素
- count:計算符合條件的元素個數
- map：對元素操作
- flatmap ：壓扁扁平,先map再flat
set集合
1、創建set
注意：set集合會自動去重
//創建
val set1 = Set(1,2,3,4,4)
val set2 = Set(1,2,5)
//遍歷
//注意：set會自動去重
set1.foreach { println}
for(s <- set1){
println(s)
}
println("*******")
/**
* 方法舉例
*/
//交集
val set3 = set1.intersect(set2)
set3.foreach{println}
val set4 = set1.&(set2)
set4.foreach{println}
println("*******")
//差集
set1.diff(set2).foreach { println }
set1.&~(set2).foreach { println }
//子集
set1.subsetOf(set2)
//最大值
println(set1.max)
//最小值
println(set1.min)
println("****")
//轉成數組，list
set1.toArray.foreach{println}
println("****")
set1.toList.foreach{println}
//mkString
println(set1.mkString)
println(set1.mkString("\t"))
Set常用方法：
- 交集：intersect ,&
- 差集: diff ,&~
- 子集:subsetOf
- 最大:max
- 最小:min
- 轉成數組，toList
- 轉成字符串：mkString(“~”)
Set方法：
1
def +(elem: A): Set[A]
為集合添加新元素，x並創建一個新的集合，除非元素已存在
2
def -(elem: A): Set[A]
移除集合中的元素，並創建一個新的集合
3
def contains(elem: A): Boolean
如果元素在集合中存在，返回 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]
從左向右丟棄元素，直到條件p不成立
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
將函數應用到不可變集合的所有元素
24
def head: A
獲取不可變集合的第一個元素
25
def init: Set[A]
返回所有元素，除了最后一個
26
def intersect(that: Set[A]): Set[A]
計算兩個集合的交集
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
返回不可變集合中數字元素的積。
36
def size: Int
返回不可變集合元素的數量
37
def splitAt(n: Int): (Set[A], Set[A])
把不可變集合拆分為兩個容器，第一個由前 n 個元素組成，第二個由剩下的元素組成
38
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否則返回false
39
def sum: A
返回不可變集合中所有數字元素之和
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]
返回 List，包含了不可變集合的所有元素
46
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可變集合的所有元素
47
def toSeq: Seq[A]
返回 Seq，包含了不可變集合的所有元素
48
def toString(): String
返回一個字符串，以對象來表示
map集合
1. map創建
Map（1 –>”bjsxt’）
Map((1,”bjsxt”))
注意：創建map時，相同的key被后面的相同的key頂替掉，只保留一個
2、獲取map的值
map.get(“1”).get
map.get(100).getOrElse(“no value”)：如果map中沒有對應項，賦值為getOrElse傳的值。
//獲取值
println(map.get("1").get)
val result = map.get(8).getOrElse("no value")
println(result)
3 、遍歷map
for,foreach
//map遍歷
for(x <- map){
println("====key:"+x._1+",value:"+x._2)
}
map.foreach(f => {
println("key:"+ f._1+" ,value:"+f._2)
})
4、遍歷key
map.keys
//遍歷key
val keyIterable = map.keys
keyIterable.foreach { key => {
println("key:"+key+", value:"+map.get(key).get)
} }
println("---------")
5、遍歷value
map.values
//遍歷value
val valueIterable = map.values
valueIterable.foreach { value => {
println("value: "+ value)
} }
6 、合並map
++ 例：map1.++(map2) --map1中加入map2
++: 例：map1.++:(map2) –map2中加入map1
注意：合並map會將map中的相同key的value替換
//合並map
val map1 = Map(
(1,"a"),
(2,"b"),
(3,"c")
)
val map2 = Map(
(1,"aa"),
(2,"bb"),
(2,90),
(4,22),
(4,"dd")
)
map1.++:(map2).foreach(println)
7、 map中的方法舉例
filter:過濾，留下符合條件的記錄
count:統計符合條件的記錄數
contains：map中是否包含某個key
exist：符合條件的記錄存在不存在
/**
* map方法
*/
//count
val countResult = map.count(p => {
p._2.equals("shsxt")
})
println(countResult)
//filter
map.filter(_._2.equals("shsxt")).foreach(println)
//contains
println(map.contains(2))
//exist
println(map.exists(f =>{
f._2.equals("xasxt")
}))
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 的默認方法
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
返回字符串對象
元組
1. 元組定義
與列表一樣，與列表不同的是元組可以包含不同類型的元素。元組的值是通過將單個的值包含在圓括號中構成的。
2. 創建元組與取值
val tuple = new Tuple（1） 可以使用new
val tuple2 = Tuple（1,2） 可以不使用new，也可以直接寫成val tuple3 =（1,2,3）
取值用”._XX” 可以獲取元組中的值
注意：tuple最多支持22個參數
//創建，最多支持22個
val tuple = new Tuple1(1)
val tuple2 = Tuple2("zhangsan",2)
val tuple3 = Tuple3(1,2,3)
val tuple4 = (1,2,3,4)
val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)
//使用
println(tuple2._1 + "\t"+tuple2._2)
val t = Tuple2((1,2),("zhangsan","lisi"))
println(t._1._2)
3、元祖遍歷
tuple.productIterator得到迭代器，進而遍歷
//遍歷
val tupleIterator = tuple22.productIterator
while(tupleIterator.hasNext){
println(tupleIterator.next())
}
4、swap,toString方法
注意：swap元素翻轉，只針對二元組
/**
* 方法
*/
//翻轉，只針對二元組
println(tuple2.swap)
//toString
println(tuple3.toString())
備注：一般針對集合的遍歷基本都是foreach ,for方法！！！！！
Scala Set 常用方法
下表列出了 Scala Set 常用的方法：
序號 方法及描述
1
def +(elem: A): Set[A]
為集合添加新元素，x並創建一個新的集合，除非元素已存在
2
def -(elem: A): Set[A]
移除集合中的元素，並創建一個新的集合
3
def contains(elem: A): Boolean
如果元素在集合中存在，返回 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]
從左向右丟棄元素，直到條件p不成立
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
將函數應用到不可變集合的所有元素
24
def head: A
獲取不可變集合的第一個元素
25
def init: Set[A]
返回所有元素，除了最后一個
26
def intersect(that: Set[A]): Set[A]
計算兩個集合的交集
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
返回不可變集合中數字元素的積。
36
def size: Int
返回不可變集合元素的數量
37
def splitAt(n: Int): (Set[A], Set[A])
把不可變集合拆分為兩個容器，第一個由前 n 個元素組成，第二個由剩下的元素組成
38
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否則返回false
39
def sum: A
返回不可變集合中所有數字元素之和
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]
返回 List，包含了不可變集合的所有元素
46
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可變集合的所有元素
47
def toSeq: Seq[A]
返回 Seq，包含了不可變集合的所有元素
48
def toString(): String
返回一個字符串，以對象來表示