一、前述
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
返回一個字串，以物件來表示