Scala编程语言入门（1）

最新推荐文章于 2024-08-05 20:09:54 发布

讲文明的喜羊羊拒绝pua

最新推荐文章于 2024-08-05 20:09:54 发布

阅读量5.8k

点赞数 19

分类专栏：大数据文章标签： scala spark java

本文链接：https://blog.csdn.net/yangwei234/article/details/122634926

版权

大数据专栏收录该内容

48 篇文章 35 订阅

订阅专栏

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而不是Integer
- scala中定义变量可以不写类型，让scala编译器自动推断
Scala 类型层次结构

在这里插入图片描述

类型	说明
Any	所有类型的父类，它有两个子类AnyRef与AnyVal
AnyVal	所有数值类型的父类
AnyRef	所有对象类型（引用类型）的父类
Unit	表示空，Unit是AnyVal的子类，它只有一个的实例（），它类似于Java中的void，但scala要比Java更加面向对象
Null	Null是AnyRef的子类，也就是说它是所有引用类型的子类。它的实例是null, 可以将null赋值给任何对象类型
Nothing	所有类型的子类不能直接创建该类型实例，某个方法抛出异常时，返回的就是Nothing类型，因为Nothing是所有类的子类，那么它可以赋值为任何类型

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中的数组封装了丰富的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。

操作	方法
求和	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 -> 元素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是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)