Scala编程语言入门
Scala简介搭建开发环境
安装JDK安装 Scala SDK安装IDEA的scala插件scala的REPL交互式解释器 Scala语法基础
scala中声明变量scala中数据类型scala中的条件表达式scala中的块表达式循环
1. for循环2. while循环 方法和函数
1. 方法2. 函数3. 方法和函数的区别4. 方法转换为函数 数组、元组、映射
数组
1. 定长数组2. 变长数组3. 遍历数组4. 数组常用操作 元组
1. 定义元组2. 示例3. 访问元组 映射Map
1. 不可变Map2. 可变Map3. Map 基本操作 Set、List
Set
1. 不可变 Set 集合2. 可变 Set 集合 ListList
1. 不可变列表2. 可变列表3. 列表操作
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类型对应
| 基础类型 | 类型说明 |
|---|---|
| Byte | 8位带符号整数 |
| Short | 16位带符号整数 |
| Int | 32位带符号整数 |
| Long | 64位带符号整数 |
| Char | 16位无符号Unicode字符 |
| String | Char类型的序列（字符串） |
| Float | 32位单精度浮点数 |
| Double | 64位双精度浮点数 |
| Boolean | true或false |
注意下 scala类型与Java的区别
scala中所有的类型都使用大写字母开头，说明是它是“类”整形使用Int而不是Integerscala中定义变量可以不写类型，让scala编译器自动推断
Scala 类型层次结构
| 类型 | 说明 |
|---|---|
| Any | 所有类型的父类，它有两个子类AnyRef与AnyVal |
| AnyVal | 所有数值类型的父类 |
| AnyRef | 所有对象类型（引用类型）的父类 |
| Unit | 表示空，Unit是AnyVal的子类，它只有一个的实例（），它类似于Java中的void，但scala要比Java更加面向对象 |
| Null | Null是AnyRef的子类，也就是说它是所有引用类型的子类。它的实例是null, 可以将null赋值给任何对象类型 |
| Nothing | 所有类型的子类不能直接创建该类型实例，某个方法抛出异常时，返回的就是Nothing类型，因为Nothing是所有类的子类，那么它可以赋值为任何类型 |
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)
| }
: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 = 152. 函数
函数在scala中属于头等公民
数字能做的事，函数也可以数字可以作为参数，所以函数也可以作为其他方法或函数的参数数字可以作为返回值，所以函数也可以作为其他方法或函数的返回值数字可以赋值给一个变量，所以函数也可以赋值给一个变量 scala 支持函数式编程，将来编写 Spark/Flink 程序中，会大量使用到函数语法：
val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体
scala> val f1 = (x: Int, y: Int) => x + y f1: (Int, Int) => Int =scala> f1(1, 2) res5: Int = 3
注意：
函数是一个对象（变量）类似于方法，函数也有输入参数和返回值函数定义不需要使用 def 定义无需指定返回值类型 示例：
scala> val add = (x: Int, y: Int) => x + y add: (Int, Int) => Int =3. 方法和函数的区别scala> add(1, 2) res6: Int = 3 // 一个函数没有赋予一个变量，则称为匿名函数，在实际开发时，基本上都是使用匿名函数 scala> (x: Int, y: Int) => x + y res7: (Int, Int) => Int =
方法是隶属于类或者对象的，在运行时，它是加载到 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 =数组、元组、映射 数组
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 Sqoop4. 数组常用操作
scala中的数组封装了丰富的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。
| 操作 | 方法 |
|---|---|
| 求和 | sum |
| 求最大值 | max |
| 求最小值 | min |
| 排序 | sorted |
示例：
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 -> 元素22. 示例
// 可以直接使用括号来定义一个元组 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"映射Map:12: error: reassignment to val a._4 = "beijing" ^
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 -> 30Set、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)
