Scala編程語言入門

Scala簡介

• scala 是運行在 JVM 上的多范式編程語言，同時支持面向物件和函式式編程，
• 早期 scala 剛出現的時候，并沒有怎么引起重視，隨著 Spark 和 Kafka 這樣基于 scala 的大資料框架的興起，scala 逐步進入大資料開發者的眼簾，scala的主要優勢是它的表達性強，
• 官網地址：http://www.scala-lang.org

為什么要使用 Scala

• 開發大資料應用程式（Spark程式、Flink程式）
• 表達能力強，一行代碼抵得上Java多行，開發速度快
• 由于運行在JVM上，所以它兼容Java，可以訪問龐大的Java類別庫，與Java框架進行互操作

搭建開發環境

• 學習如何撰寫scala代碼之前，需要先安裝scala編譯器以及開發工具
• Java程式編譯執行流程

• Scala程式編譯執行流程

• scala程式運行需要依賴于Java類別庫，必須要有**Java運行環境**，scala才能正確執行，要編譯運行scala程式需要
  • jdk ( jvm )
  • scala編譯器（scala SDK）

安裝JDK

• 安裝JDK 1.8 64位版本，并配置好環境變數

安裝 Scala SDK

• scala SDK是scala語言的編譯器，要開發scala程式，必須要先安裝SDK
• 訪問地址：https://www.scala-lang.org/download/2.11.8.html，根據自己電腦的實際情況下載對應的安裝包

• 下載好后，解壓縮并配置環境變數

$ vim ~/.bash_profile
# Scala環境變數
export SCALA_HOME=/Volumes/D/tools/scala/scala-2.11.8
export PATH=$PATH:$SCALA_HOME/bin

$ source ~/.bash_profile
$ scala -version
Scala code runner version 2.11.8 -- Copyright 2002-2016, LAMP/EPFL

安裝IDEA的scala插件

scala的REPL互動式解釋器

• Scala提供的最重要的一個工具是互動模式（REPL），REPL是一個互動式解釋器，可以即時編譯、運行代碼并回傳結果，方便前期做學習和測驗
• REPL：R(read)、E(evaluate) 、P(print)、L(loop)

Scala語法基礎

scala中宣告變數

• 語法格式：

val/var 變數名稱:變數型別 = 初始值

• 其中：
  • val定義的是不可重新賦值的變數(值不可修改)
  • var定義的是可重新賦值的變數(值可以修改)
• 注意：
  • scala中宣告變數是變數名稱在前，變數型別在后，跟java是正好相反
  • scala的陳述句最后不需要添加分號

• 惰性變數：Scala中使用關鍵字lazy來定義惰性變數，實作延遲加載(懶加載)
• 惰性變數只能是不可變變數，并且只有在呼叫惰性變數時，才會去實體化這個變數，
• 語法格式：

lazy val 變數名 = 運算式

scala中資料型別

• scala中的型別絕大多數和Java型別對應

• 注意下 scala型別與Java的區別

  • scala中所有的型別都使用大寫字母開頭，說明是它是“類”
  • 整形使用Int而不是Integer
  • scala中定義變數可以不寫型別，讓scala編譯器自動推斷

• Scala 型別層次結構

scala中的條件運算式

• scala條件運算式的語法和Java類似

scala中的塊運算式

• 定義變數時用 {} 包含一系列運算式，其中塊的最后一個運算式的值就是塊的值，
• 在scala解釋器中先輸入 :paste ,然后寫多行代碼, 之后按=ctrl+d結束輸入

val x = 0
val result = {
  val y = x + 10
  val z = y + "-hello"
  val m = z + "-scala"
  "over"
}
// result的值就是塊運算式的結果    
// 后期一個方法的回傳值不需要加上return,把要回傳的結果放在方法的最后一行就可以了 

回圈

• 在scala中，可以使用for和while，但一般推薦使用for運算式，因為for運算式語法更簡潔

1. for回圈

• 語法結構

for (i <- 運算式/陣列/集合){
    //運算式
}

• 簡單 for 回圈

scala> val nums = 1 to 10
nums: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> for (i <- nums) println(i)
1
2
3
4
5
6
7
8
9
10

• 雙重 for 回圈

scala> for (i <- 1 to 3; j <- 1 to 3) println(i * 10 + j)
11
12
13
21
22
23
31
32
33

scala> :paste
// Entering paste mode (ctrl-D to finish)
// 雙重for回圈列印99乘法表
for (i <- 1 to 9; j <- 1 to i) {
  print(i + "*" + j + "=" + i * j + "\t")
  if (i == j) println()
}

// Exiting paste mode, now interpreting.

1*1=1
2*1=2	2*2=4
3*1=3	3*2=6	3*3=9
4*1=4	4*2=8	4*3=12	4*4=16
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

• 守衛：在for運算式中可以添加if判斷陳述句，這個if判斷稱為守衛

// 語法結構
for(i <- 運算式/陣列/集合 if 運算式) {
    // 運算式
}
scala> for (i <- 1 to 10 if i > 5) println(i)
6
7
8
9
10

• for推導式：在for回圈體中，以yield運算式開始，這類回圈能構建出一個新的集合，我們把這類回圈稱為推導式

// for運算式中以yield開始，該for運算式會構建出一個集合
val v = for (i <- 1 to 5) yield i * 10
v: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50)

2. while回圈

• scala中while回圈和Java中是一致的

• 語法結構

while(回傳值為布爾型別的運算式){
    //運算式
}

• 演示

scala> var x = 10
x: Int = 10

scala> while (x > 5) { println(x); x -= 1 }
10
9
8
7
6

方法和函式

1. 方法

• 語法：

def methodName (引數名:引數型別, 引數名:引數型別) : [return type] = {
    // 方法體：一系列的代碼
}

• 說明：
  • 引數串列的引數型別不能省略
  • 回傳值型別可以省略，由 scala 編譯器自動推斷
  • 回傳值可以不寫 return，默認就是 {} 塊運算式的值
• 示例：

scala> def add(a: Int, b: Int) = a + b
add: (a: Int, b: Int)Int

scala> add(1, 2)
res5: Int = 3

• 注意：
  • 如果定義遞回方法，必須指定回傳值型別，例如

// 錯誤定義
scala> def m1(x: Int) = {
     | if (x == 1) 1
     | else x * m1(x - 1)
     | }
<console>:15: error: recursive method m1 needs result type
       else x * m1(x - 1)
                ^
// 正確定義
scala> def m1(x: Int): Int = {
     | if (x == 1) 1
     | else x * m1(x - 1)
     | }
m1: (x: Int)Int

scala> m1(10)
res0: Int = 3628800

• 方法的引數：
  • 默認引數：在定義方法時可以給引數定義一個默認值
  • 帶名引數：在呼叫方法時，可以指定引數的名稱來進行呼叫
  • 變長引數：如果方法的引數是不固定的，可以定義一個方法的引數是變長引數

// 默認引數
scala> def add(x: Int = 0, y: Int = 0) = x + y
add: (x: Int, y: Int)Int

scala> add(10)
res1: Int = 10

scala> add(10, 20)
res2: Int = 30

// 帶名引數
scala> def add(x: Int = 0, y: Int = 0) = x + y
add: (x: Int, y: Int)Int

scala> add(y = 1)
res3: Int = 1

// 變長引數
scala> def add(num: Int*) = num.sum
add: (num: Int*)Int

scala> add(1,2,3,4,5)
res4: Int = 15

2. 函式

• 函式在scala中屬于頭等公民
  • 數字能做的事，函式也可以
  • 數字可以作為引數，所以函式也可以作為其他方法或函式的引數
  • 數字可以作為回傳值，所以函式也可以作為其他方法或函式的回傳值
  • 數字可以賦值給一個變數，所以函式也可以賦值給一個變數
• scala 支持函式式編程，將來撰寫 Spark/Flink 程式中，會大量使用到函式
• 語法：

val 函式變數名 = (引數名:引數型別, 引數名:引數型別....) => 函式體

scala> val f1 = (x: Int, y: Int) => x + y
f1: (Int, Int) => Int = <function2>

scala> f1(1, 2)
res5: Int = 3

• 注意：
  • 函式是一個物件（變數）
  • 類似于方法，函式也有輸入引數和回傳值
  • 函式定義不需要使用 def 定義
  • 無需指定回傳值型別
• 示例：

scala> val add = (x: Int, y: Int) => x + y
add: (Int, Int) => Int = <function2>

scala> add(1, 2)
res6: Int = 3

// 一個函式沒有賦予一個變數，則稱為匿名函式，在實際開發時，基本上都是使用匿名函式
scala> (x: Int, y: Int) => x + y
res7: (Int, Int) => Int = <function2>

3. 方法和函式的區別

• 方法是隸屬于類或者物件的，在運行時，它是加載到 JVM 的方法區中

• 可以將函式物件賦值給一個變數，在運行時，它是加載到 JVM 的堆記憶體中

• 函式是一個物件，繼承自FunctionN，函式物件有apply，curried，toString，tupled這些方法，而方法則沒有，

4. 方法轉換為函式

• 有時候需要將方法轉換為函式，作為變數傳遞，就需要將方法轉換為函式
• 使用 _ 即可將方法轉換為函式
• 示例：

scala> def add(x: Int, y: Int) = x + y
add: (x: Int, y: Int)Int

scala> var a = add _
a: (Int, Int) => Int = <function2>

陣列、元組、映射

陣列

• scala中陣列的概念是和Java類似，可以用陣列來存放同型別的一組資料
• scala中，有兩種陣列，一種是定長陣列，另一種是變長陣列

1. 定長陣列

• 定長陣列指的是陣列的長度是不允許改變的，陣列的元素是可以改變的
• 語法：

// 通過指定長度定義陣列
val/var 變數名 = new Array[元素型別](陣列長度)

// 用元素直接初始化陣列
val/var 變數名 = Array(元素1, 元素2, 元素3...)

• 注意
  • 在scala中，陣列的泛型使用[]來指定
  • 使用()來獲取元素
• 示例：

scala> val a = new Array[Int](10)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> a(0)
res0: Int = 0

scala> a(0) = 10

scala> a
res2: Array[Int] = Array(10, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> val b = Array("Hadoop", "Spark", "Hive")
b: Array[String] = Array(Hadoop, Spark, Hive)

scala> b(0)
res3: String = Hadoop

scala> b.length
res4: Int = 3

2. 變長陣列

• 變長陣列指的是陣列的長度是可變的，可以往陣列中添加、洗掉元素
• 創建變長陣列，需要提前匯入ArrayBuffer類

import scala.collection.mutable.ArrayBuffer

// 創建空的ArrayBuffer變長陣列
val/var a = ArrayBuffer[元素型別]()
// 創建帶有初始元素的ArrayBuffer
val/var a = ArrayBuffer(元素1，元素2，元素3....)

• 示例：

// 匯入ArrayBuffer型別
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
// 定義一個長度為0的整型變長陣列
scala> val a = ArrayBuffer[Int]()
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
// 定義一個有初始元素的變長陣列
scala> val b = ArrayBuffer("hadoop", "storm", "spark")
b: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)

• 變長陣列的增刪改操作

  • 使用+=添加元素

  • 使用-=洗掉元素

  • 使用++=追加一個陣列到變長陣列

• 示例：

// 定義變長陣列
scala> val a = ArrayBuffer("Hadoop", "Spark", "Flink")
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(Hadoop, Spark, Flink)
// 追加一個元素
scala> a += "Flume"
res0: a.type = ArrayBuffer(Hadoop, Spark, Flink, Flume)
// 洗掉一個元素
scala> a -= "Hadoop"
res1: a.type = ArrayBuffer(Spark, Flink, Flume)
// 追加一個陣列
scala> a ++= Array("Hive", "Sqoop")
res2: a.type = ArrayBuffer(Spark, Flink, Flume, Hive, Sqoop)

3. 遍歷陣列

• 可以使用以下兩種方式來遍歷陣列：

  • 使用for運算式 直接遍歷陣列中的元素
  • 使用 索引 獲得陣列中的元素

• 示例：

scala> for (i <- a) println(i)
Spark
Flink
Flume
Hive
Sqoop
//0 to n    ——包含0，也包含n
scala> for (i <- 0 to a.length - 1) println(a(i))
Spark
Flink
Flume
Hive
Sqoop
//0 until n ——生成一系列的數字，包含0，不包含n
scala> for (i <- 0 until a.length) println(a(i))
Spark
Flink
Flume
Hive
Sqoop

4. 陣列常用操作

• scala中的陣列封裝了豐富的計算操作，將來在對資料處理的時候，不需要我們自己再重新實作，

• 示例：

scala> val array = Array(1, 2, 3, 4, 5)
array: Array[Int] = Array(1, 2, 3, 4, 5)
// 求和
scala> array.sum
res0: Int = 15
// 求最小值
scala> array.min
res1: Int = 1
// 升序
scala> array.sorted
res2: Array[Int] = Array(1, 2, 3, 4, 5)
// 降序
scala> array.sorted.reverse
res3: Array[Int] = Array(5, 4, 3, 2, 1)

元組

• 元組可以用來包含一組不同型別的值，例如：姓名，年齡，性別，出生年月，元組的元素是不可變 的，

1. 定義元組

// 使用括號來定義元組
val/var 元組變數名稱 = (元素1, 元素2, 元素3....)
// 使用箭頭來定義元組（元組只有兩個元素）
val/var 元組 = 元素1 -> 元素2

2. 示例

// 可以直接使用括號來定義一個元組
scala> val a = (1, "zhangsan", 20, "shenzhen")
a: (Int, String, Int, String) = (1,zhangsan,20,shenzhen)
// 使用箭頭來定義元素
scala> val b = 1 -> 2
b: (Int, Int) = (1,2)

3. 訪問元組

• 使用 _1、_2、_3....來訪問元組中的元素，元組的index從1開始，_1表示訪問第一個元素，依次類推
• 示例：

scala> val a = (1, "zhangsan", 20, "shenzhen")
a: (Int, String, Int, String) = (1,zhangsan,20,shenzhen)

scala> a._1
res0: Int = 1

scala> a._2
res1: String = zhangsan

scala> a._3
res2: Int = 20

scala> a._4
res3: String = shenzhen
// 不能修改元組中的值
scala> a._4 = "beijing"
<console>:12: error: reassignment to val
       a._4 = "beijing"
            ^ 

映射Map

• Map可以稱之為映射，它是由鍵值對組成的集合，scala當中的Map集合與java當中的Map類似，也是key，value對形式的，
• 在scala中，Map也分為不可變Map和可變 Map，

1. 不可變Map

• 定義語法：

val/var map = Map(鍵->值, 鍵->值, 鍵->值...)    // 推薦這種寫法，可讀性更好 
val/var map = Map((鍵, 值), (鍵, 值), (鍵, 值), (鍵, 值)...)

• 示例：

scala> val map1 = Map("zhangsan" -> 30, "lisi" -> 40)
map1: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)

scala> val map2 = Map(("zhangsan", 30), ("lisi", 40))
map2: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40)
// 根據key獲取value
scala> map1("zhangsan")
res4: Int = 30
// 獲取不存在的key，或報例外
scala> map1("zhangsan1")
java.util.NoSuchElementException: key not found: zhangsan1
  at scala.collection.MapLike$class.default(MapLike.scala:228)
  at scala.collection.AbstractMap.default(Map.scala:59)
  at scala.collection.MapLike$class.apply(MapLike.scala:141)
  at scala.collection.AbstractMap.apply(Map.scala:59)
  ... 32 elided

2. 可變Map

• 可變Map需要手動匯入import scala.collection.mutable.Map，定義語法與不可變Map一致，
• 示例：

// 導包
scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map
// 定義可變的 Map
scala> val map3 = Map("zhangsan" -> 30, "lisi" -> 40)
map3: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)
// 獲取zhangsan這個key對應的value
scala> map3("zhangsan")
res6: Int = 30
// 給zhangsan這個key重新賦值value
scala> map3("zhangsan") = 50
// 顯示 map3
scala> map3
res8: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 50)

3. Map 基本操作

• 創建一個可變的Map

scala> val map = Map("zhangsan" -> 30, "lisi" -> 40)
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)

• 按照 key 獲取 value

scala> map("zhangsan")
res9: Int = 30
// 獲取wangwu的年齡，如果wangwu不存在，則回傳-1 比較友好，避免遇到不存在的key而報錯
scala> map.getOrElse("wangwu", -1)
res10: Int = -1

• 修改 key 對應的 value

scala> map("lisi") = 50

• 添加 key-value 鍵值對

scala> map += ("wangwu" -> 35)
res12: map.type = Map(lisi -> 50, zhangsan -> 30, wangwu -> 35)

• 洗掉 key-value 鍵值對

scala> map -= "wangwu"
res13: map.type = Map(lisi -> 50, zhangsan -> 30)

• 獲取所有 key 和所有 value

// 獲取所有的key
scala> map.keys
res14: Iterable[String] = Set(lisi, zhangsan)
// 獲取所有的key
scala> map.keySet
res15: scala.collection.Set[String] = Set(lisi, zhangsan)
// 獲取所有的value
scala> map.values
res16: Iterable[Int] = HashMap(50, 30)

• 遍歷 map

scala> for (k <- map.keys) println(k + " -> " + map(k))
lisi -> 50
zhangsan -> 30

scala> for (kv <- map) println(kv._1 + " -> " + kv._2)
lisi -> 50
zhangsan -> 30

scala> for ((k, v) <- map) println(k + " -> " + v)
lisi -> 50
zhangsan -> 30

Set、List

Set

• Set是代表沒有重復元素的集合，Set具備以下性質：
  • 元素不重復
  • 不保證插入順序
• scala中的set集合也分為兩種，一種是不可變集合，另一種是可變集合，

1. 不可變 Set 集合

• 語法：

//創建一個空的不可變集
val/var 變數名 = Set[型別]()

//給定元素來創建一個不可變集
val/var 變數名 = Set[型別](元素1, 元素2, 元素3...)

• 示例：

// 創建set集合
scala> val s = Set(1, 1, 2, 3, 4, 4, 5)
s: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
// 獲取集合大小
scala> s.size
res21: Int = 5
// 遍歷集合
scala> for (i <- s) println(i)
5
1
2
3
4
// 添加元素生成新的集合
scala> s + 6
res24: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
// 洗掉一個元素
scala> s - 1
res26: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)
// 洗掉set集合中存在的元素
scala> s -- Set(2, 3)
res27: scala.collection.immutable.Set[Int] = Set(5, 1, 4)
// 求兩個集合的并集
scala> s ++ Set(6, 7, 8)
res29: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
// 求兩個集合的交集
scala> s & Set(3, 4, 5, 6)
res31: scala.collection.immutable.Set[Int] = Set(5, 3, 4)

// 注意：這里對不可變的set集合進行添加洗掉等操作，對于該集合來說是沒有發生任何變化，這里是生成了新的集合，新的集合相比于原來的集合來說發生了變化，
scala> s
res32: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

2. 可變 Set 集合

• 要使用可變集，必須要手動匯入： import scala.collection.mutable.Set
• 示例：

// 導包
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set
// 定義可變的set集合
scala> val set = Set(1, 2, 3, 4, 5)
set: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4)
// 添加單個元素
scala> set += 6
res33: set.type = Set(1, 5, 2, 6, 3, 4)
// 添加多個元素
scala> set += (6, 7, 8, 9)
res34: set.type = Set(9, 1, 5, 2, 6, 3, 7, 4, 8)
// 添加一個set集合中的元素
scala> set ++= Set(10, 11)
res35: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 11, 8)
// 洗掉一個元素
scala> set -= 11
res36: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 8)
// 洗掉多個元素
scala> set -= (9, 10)
res37: set.type = Set(1, 5, 2, 6, 3, 7, 4, 8)
// 洗掉一個 set 子集
scala> set --= Set(7, 8)
res38: set.type = Set(1, 5, 2, 6, 3, 4)
// 移除remove方法
scala> set.remove(1)
res39: Boolean = true

scala> set
res40: scala.collection.mutable.Set[Int] = Set(5, 2, 6, 3, 4)

List

List

• List是scala中最重要的、也是最常用的資料結構，List具備以下性質：
  • 可以保存重復的值
  • 有先后順序
• 在scala中，也有兩種串列，一種是不可變串列、另一種是可變串列

1. 不可變串列

• 不可變串列就是串列的元素、長度都是不可變的
• 語法：

val/var 變數名 = List(元素1, 元素2, 元素3...)

//使用 Nil 創建一個不可變的空串列
val/var 變數名 = Nil

//使用 :: 方法創建一個不可變串列
val/var 變數名 = 元素1 :: 元素2 :: Nil

• 示例：

// 創建一個不可變串列，存放以下幾個元素（1,2,3,4）
scala> val list1 = List(1, 2, 3, 4)
list1: List[Int] = List(1, 2, 3, 4)
// 使用Nil創建一個不可變的空串列
scala> val list2 = Nil
list2: scala.collection.immutable.Nil.type = List()
// 使用 :: 方法創建串列，包含1、2、3三個元素
scala> val list3 = 1::2::3::Nil
list3: List[Int] = List(1, 2, 3)

2. 可變串列

• 可變串列就是串列的元素、長度都是可變的，
• 要使用可變串列，先要匯入 import scala.collection.mutable.ListBuffer
• 語法：

// 使用ListBuffer[元素型別]() 創建空的可變串列
val/var 變數名 = ListBuffer[Int]()
// 使用ListBuffer(元素1, 元素2, 元素3...)創建可變串列，語法結構
val/var 變數名 = ListBuffer(元素1，元素2，元素3...)

• 示例：

// 導包
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
// 定義一個空的可變串列
scala> val a = ListBuffer[Int]()
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()
// 定義一個有初始元素的可變串列
scala> val b = ListBuffer(1, 2, 3, 4)
b: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

3. 串列操作

// 定義一個可變的串列
scala> val list = ListBuffer(1, 2, 3, 4)
list: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)
// 獲取第一個元素
scala> list(0)
res41: Int = 1
scala> list.head
res42: Int = 1
// 獲取除了第一個元素外其他元素組成的串列
scala> list.tail
res43: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 4)
// 添加單個元素
scala> list += 5
res44: list.type = ListBuffer(1, 2, 3, 4, 5)
// 添加一個不可變的串列
scala> list ++= List(6, 7)
res45: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)
// 添加一個可變的串列
scala> list ++= ListBuffer(8, 9)
res46: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
// 洗掉單個元素
scala> list -= 9
res47: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8)
// 洗掉一個不可變的串列存在的元素
scala> list --= List(7, 8)
res48: list.type = ListBuffer(1, 2, 3, 4, 5, 6)
// 洗掉一個可變的串列存在的元素
scala> list --= ListBuffer(5, 6)
res49: list.type = ListBuffer(1, 2, 3, 4)
// toList根據可變的串列生成一個不可變串列，原串列不變
scala> list.toList
res50: List[Int] = List(1, 2, 3, 4)
// toArray根據可變的串列生成一個新的不可變陣列，原串列不變
scala> list.toArray
res51: Array[Int] = Array(1, 2, 3, 4)