Scala第十章节(列表、集相关知识点)

列表

列表(List)是Scala中最重要的, 也是最常用的一种数据结构。它存储的数据, 特点是: **有序****,** **可重复**. 在Scala中，列表分为两种, 即: 不可变列表和可变列表.

解释:

1. 有序 的意思并不是排序, 而是指 元素的存入顺序和取出顺序是一致的 .
2. 可重复 的意思是 列表中可以添加重复元素

3.1 不可变列表

3.1.1 特点

不可变列表指的是: 列表的元素、长度都是不可变的。

3.1.2 语法

• 格式一: 通过 小括号 直接初始化.

val/var 变量名 = List(元素1, 元素2, 元素3...)

• 格式二: 通过 Nil 创建一个空列表.

val/var 变量名 = Nil

• 格式三: 使用 :: 方法实现

val/var 变量名 = 元素1 :: 元素2 :: Nil

注意: 使用**::拼接方式来创建列表，必须在最后添加一个Nil**

3.2.2 示例

需求

1. 创建一个不可变列表，存放以下几个元素（1,2,3,4）
2. 使用 Nil 创建一个不可变的空列表
3. 使用 :: 方法创建列表，包含-2、-1两个元素

参考代码

//案例: 演示不可变列表.
object ClassDemo08 {
def main(args: Array[String]): Unit = {
//1. 创建一个不可变列表，存放以下几个元素（1,2,3,4）
val list1 = List(1, 2, 3, 4)
//2. 使用`Nil`创建一个不可变的空列表
val list2 = Nil
//3. 使用`::`方法创建列表，包含-2、-1两个元素
val list3 = -2 :: -1 :: Nil
//4. 打印结果.
println(s"list1: ${list1}")
println(s"list2: ${list2}")
println(s"list3: ${list3}")
}
}

3.2 可变列表

3.2.1 特点

可变列表指的是列表的元素、长度都是可变的****.

3.2.2 语法

• 要使用可变列表, 必须先导包.

import scala.collection.mutable.ListBuffer

小技巧: 可变集合都在 mutable 包中, 不可变集合都在 immutable 包中（默认导入）.

• 格式一: 创建空的可变列表

val/var 变量名 = ListBuffer[数据类型]()

• 格式二: 通过 小括号 直接初始化

val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

3.2.3 示例

需求

1. 创建空的整形可变列表.
2. 创建一个可变列表，包含以下元素：1,2,3,4

参考代码

//1. 导包
import scala.collection.mutable.ListBuffer
//案例: 演示可变列表.
object ClassDemo09 {
def main(args: Array[String]): Unit = {
//2. 创建空的整形可变列表.
val list1 = new ListBuffer[Int]()
//3. 创建一个可变列表，包含以下元素：1,2,3,4
val list2 = ListBuffer(1, 2, 3, 4)
println(s"list1: ${list1}")
println(s"list2: ${list2}")
}
}

3.2.4 可变列表的常用操作

关于可变列表的常见操作如下:

格式	功能
列表名(索引)	根据索引(索引从0开始), 获取列表中的指定元素.
列表名(索引) = 值	修改元素值
+=	往列表中添加单个元素
++=	往列表中追加一个列表
-=	删除列表中的某个指定元素
--=	以列表的形式, 删除列表中的多个元素.
toList	将可变列表(ListBuffer)转换为不可变列表(List)
toArray	将可变列表(ListBuffer)转换为数组

示例

1. 定义一个可变列表包含以下元素：1,2,3
2. 获取第一个元素, 并打印结果到控制台.
3. 添加一个新的元素：4
4. 追加一个列表，该列表包含以下元素：5,6,7
5. 删除元素7
6. 删除元素3, 4
7. 将可变列表转换为不可变列表
8. 将可变列表转换为数组
9. 打印结果

参考代码

//案例: 演示可变列表的常见操作.
object ClassDemo10 {
def main(args: Array[String]): Unit = {
//1. 定义一个可变列表包含以下元素：1,2,3
val list1 = ListBuffer(1, 2, 3)
//2. 获取第一个元素, 并打印结果到控制台.
println(list1(0))
//3. 添加一个新的元素：4
list1 += 4
//4. 追加一个列表，该列表包含以下元素：5,6,7
list1 ++= List(5, 6, 7)
//5. 删除元素7
list1 -= 7
//6. 删除元素3, 4
list1 --= List(3, 4)
//7. 将可变列表转换为不可变列表
val list2 = list1.toList
//8. 将可变列表转换为数组
val arr = list1.toArray
//9. 打印结果.
println(s"list1: ${list1}")
println(s"list2: ${list2}")
println(s"arr: ${arr}")
}
}

3.3 列表的常用操作

3.3.1 格式详解

在实际开发中, 我们经常要操作列表, 以下列举的是列表的常用的操作:

格式	功能
isEmpty	判断列表是否为空
++	拼接两个列表, 返回一个新的列表
head	获取列表的首个元素
tail	获取列表中除首个元素之外, 其他所有的元素
reverse	对列表进行反转, 返回一个新的列表
take	获取列表中的前缀元素(具体个数可以自定义)
drop	获取列表中的后缀元素(具体个数可以自定义)
flatten	对列表进行扁平化操作, 返回一个新的列表
zip	对列表进行拉链操作, 即: 将两个列表合并成一个列表
unzip	对列表进行拉开操作, 即: 将一个列表拆解成两个列表
toString	将列表转换成其对应的默认字符串形式
mkString	将列表转换成其对应的指定字符串形式
union	获取两个列表的并集元素, 并返回一个新的列表
intersect	获取两个列表的交集元素, 并返回一个新的列表
diff	获取两个列表的差集元素, 并返回一个新的列表

3.3.2 示例一: 基础操作

需求

1. 定义一个列表list1，包含以下元素：1,2,3,4
2. 使用isEmpty方法判断列表是否为空, 并打印结果.
3. 再定义一个列表list2，包含以下元素: 4,5,6
4. 使用 ++ 将两个列表拼接起来, 并打印结果.
5. 使用head方法，获取列表的首个元素, 并打印结果.
6. 使用tail方法，获取列表中除首个元素之外, 其他所有的元素, 并打印结果.
7. 使用reverse方法将列表的元素反转, 并打印反转后的结果.
8. 使用take方法获取列表的前缀元素, 并打印结果.
9. 使用drop方法获取列表的后缀元素, 并打印结果.

参考代码

//案例: 演示列表的基础操作.
object ClassDemo11 {
def main(args: Array[String]): Unit = {
//1. 定义一个列表list1，包含以下元素：1,2,3,4
val list1 = List(1, 2, 3, 4)
//2. 使用isEmpty方法判断列表是否为空, 并打印结果.
println(s"isEmpty: ${list1.isEmpty}")
//3. 再定义一个列表list2，包含以下元素: 4,5,6
val list2 = List(4, 5, 6)
//4. 使用`++`将两个列表拼接起来, 并打印结果.
val list3 = list1 ++ list2
println(s"list3: ${list3}")
//5. 使用head方法，获取列表的首个元素, 并打印结果.
println(s"head: ${list3.head}")
//6. 使用tail方法，获取列表中除首个元素之外, 其他所有的元素, 并打印结果.
println(s"tail: ${list3.tail}")
//7. 使用reverse方法将列表的元素反转, 并打印反转后的结果.
val list4 = list3.reverse
println(s"list4: ${list4}")
//8. 使用take方法获取列表的前缀元素(前三个元素), 并打印结果.
println(s"take: ${list3.take(3)}")
//9. 使用drop方法获取列表的后缀元素(除前三个以外的元素), 并打印结果.
println(s"drop: ${list3.drop(3)}")
}
}

3.3.3 示例二:扁平化(压平)

概述

扁平化表示将嵌套列表中的所有具体元素单独的放到一个新列表中. 如下图:

注意: 如果某个列表中的所有元素都是列表, 那么这样的列表就称之为: 嵌套列表

需求

1. 定义一个列表, 该列表有三个元素, 分别为：List(1,2)、List(3)、List(4,5)
2. 使用flatten将这个列表转换为List(1,2,3,4,5)
3. 打印结果.

参考代码

//案例: 演示扁平化操作.
object ClassDemo12 {
def main(args: Array[String]): Unit = {
//1. 定义一个列表, 该列表有三个元素, 分别为：List(1,2)、List(3)、List(4,5)
val list1 = List(List(1,2), List(3), List(4, 5))
//2. 使用flatten将这个列表转换为List(1,2,3,4,5)
val list2 = list1.flatten
//3. 打印结果
println(list2)
}
}

3.3.4 示例三:拉链与拉开

概述

• 拉链：将两个列表，组合成一个元素为元组的列表

  解释: 将列表List("张三", "李四"), List(23, 24)组合成列表List((张三,23), (李四,24))

• 拉开：将一个包含元组的列表，拆解成包含两个列表的元组

  解释: 将列表List((张三,23), (李四,24))拆解成元组(List(张三, 李四),List(23, 24))

需求

1. 定义列表names, 保存三个学生的姓名，分别为：张三、李四、王五
2. 定义列表ages, 保存三个学生的年龄，分别为：23, 24, 25
3. 使用zip将列表names和ages, 组合成一个元素为元组的列表list1
4. 使用unzip将列表list1拆解成包含两个列表的元组tuple1
5. 打印结果

参考代码

//案例: 演示拉链与拉开
object ClassDemo13 {
def main(args: Array[String]): Unit = {
//1. 定义列表names, 保存三个学生的姓名，分别为：张三、李四、王五
val names = List("张三", "李四", "王五")
//2. 定义列表ages, 保存三个学生的年龄，分别为：23, 24, 25
val ages = List(23, 24, 25)
//3. 使用zip将列表names和ages, 组合成一个元素为元组的列表list1.
val list1 = names.zip(ages)
//4. 使用unzip将列表list1拆解成包含两个列表的元组tuple1
val tuple1 = list1.unzip
//5. 打印结果
println("拉链: "+ list1)
println("拉开: " + tuple1)
}
}

3.3.5 示例四: 列表转字符串

概述

将列表转换成其对应的字符串形式, 可以通过 toString方法或者mkString方法 实现, 其中

• toString方法: 可以返回List中的所有元素
• mkString方法: 可以将元素以指定分隔符拼接起来。

注意: 默认没有分隔符.

需求

1. 定义一个列表，包含元素：1,2,3,4
2. 使用toString方法输出该列表的元素
3. 使用mkString方法, 用冒号将元素都拼接起来, 并打印结果.

参考代码

//案例: 演示将列表转成其对应的字符串形式.
object ClassDemo14 {
def main(args: Array[String]): Unit = {
//1. 定义一个列表，包含元素：1,2,3,4
val list1 = List(1, 2, 3, 4)
//2. 使用toString方法输出该列表的元素
println(list1.toString)
//简写形式, 因为: 输出语句打印对象, 默认调用了该对象的toString()方法
println(list1)
println("-" * 15)
//3. 使用mkString方法, 用冒号将元素都拼接起来, 并打印结果.
println(list1.mkString(":"))
}
}

3.3.6 示例五:并集,交集,差集

概述

操作数据时, 我们可能会遇到求并集, 交集, 差集的需求, 这是时候就要用到union, intersect, diff这些方法了, 其中

• union: 表示对两个列表取并集，而且不去重

例如: list1.union(list2), 表示获取list1和list2中所有的元素(元素不去重).

如果想要去除重复元素, 则可以通过 distinct 实现.

• intersect: 表示对两个列表取交集

例如: list1.intersect(list2), 表示获取list1, list2中都有的元素.

• diff: 表示对两个列表取差集.

例如：list1.diff(list2)，表示获取list1中有, 但是list2中没有的元素.

需求

1. 定义列表list1，包含以下元素：1,2,3,4
2. 定义列表list2，包含以下元素：3,4,5,6
3. 使用union获取这两个列表的并集
4. 在第三步的基础上, 使用distinct去除重复的元素
5. 使用intersect获取列表list1和list2的交集
6. 使用diff获取列表list1和list2的差集
7. 打印结果

参考代码

//案例: 演示获取并集, 交集, 差集.
object ClassDemo15 {
def main(args: Array[String]): Unit = {
//1. 定义列表list1，包含以下元素：1,2,3,4
val list1 = List(1, 2, 3, 4)
//2. 定义列表list2，包含以下元素：3,4,5,6
val list2 = List(3, 4, 5, 6)
//3. 使用union获取这两个列表的并集
val unionList = list1.union(list2)
//4. 在第三步的基础上, 使用distinct去除重复的元素
val distinctList = unionList distinct
//5. 使用intersect获取列表list1和list2的交集
val intersectList = list1.intersect(list2)
//6. 使用diff获取列表list1和list2的差集
val diffList = list1.diff(list2)
//7. 打印结果
println("并集, 不去重: " + unionList)
println("并集, 去重: " + distinctList)
println("交集: " + intersectList)
println("差集: " + diffList)
}
}

集

4.1 概述

Set(也叫: 集)代表没有重复元素的集合 。特点是: 唯一, 无序

Scala中的集分为两种，一种是不可变集，另一种是可变集。

解释:

1. 唯一 的意思是 Set中的元素具有唯一性, 没有重复元素
2. 无序 的意思是 Set集中的元素, 添加顺序和取出顺序不一致

4.2 不可变集

不可变集指的是元素 , 集的长度都不可变.

4.2.1 语法

• 格式一: 创建一个空的不可变集

val/var 变量名 = Set[类型]()

• 格式二: 给定元素来创建一个不可变集

val/var 变量名 = Set(元素1, 元素2, 元素3...)

4.2.2 示例一:创建不可变集

需求

1. 定义一个空的整型不可变集.
2. 定义一个不可变集，保存以下元素：1,1,3,2,4,8.
3. 打印结果.

参考代码

//案例: 演示不可变集.
object ClassDemo16 {
def main(args: Array[String]): Unit = {
//1. 定义一个空的整型不可变集.
val set1 = Set[Int]()
//2. 定义一个不可变集，保存以下元素：1,1,3,2,4,8.
val set2 = Set(1, 1, 3, 2, 4, 8)
//3. 打印结果.
println(s"set1: ${set1}")
println(s"set2: ${set2}")
}
}

4.2.3 示例二:不可变集的常见操作

格式

1. 获取集的大小（ size ）
2. 遍历集（ 和遍历数组一致 ）
3. 添加一个元素，生成一个新的Set（ + ）
4. 拼接两个集，生成一个新的Set（ ++ ）
5. 拼接集和列表，生成一个新的Set（ ++ ）

注意:

1. **-(减号) **表示删除一个元素, 生成一个新的Set
2. **-- **表示批量删除某个集中的元素, 从而生成一个新的Set

需求

1. 创建一个集，包含以下元素：1,1,2,3,4,5
2. 获取集的大小, 并打印结果.
3. 遍历集，打印每个元素.
4. 删除元素1，生成新的集, 并打印.
5. 拼接另一个集Set(6, 7, 8), 生成新的集, 并打印.
6. 拼接一个列表List(6,7,8, 9), 生成新的集, 并打印.

参考代码

//案例: 演示不可变集的常用操作.
object ClassDemo17 {
def main(args: Array[String]): Unit = {
//1. 创建一个集，包含以下元素：1,1,2,3,4,5
val set1 = Set(1, 1, 2, 3, 4, 5)
//2. 获取集的大小
println("set1的长度为: " + set1.size)
//3. 遍历集，打印每个元素
println("set1集中的元素为: ")
for(i <- set1) println(i)
println("-" * 15)
//4. 删除元素1，生成新的集
val set2 = set1 - 1
println("set2: " + set2)
//5. 拼接另一个集（6, 7, 8)
val set3 = set1 ++ Set(6, 7, 8)
println("set3: " + set3)
//6. 拼接一个列表(6,7,8, 9)
val set4 = set1 ++ List(6, 7, 8, 9)
println("set4: " + set4)
}
}

4.3 可变集

4.3.1 概述

可变集指的是元素 , 集的长度都可变, 它的创建方式和不可变集的创建方式一致，只不过需要先导入可变集类。

手动导入： import scala.collection.mutable.Set

4.3.2 示例

需求

1. 定义一个可变集，包含以下元素: 1,2,3, 4
2. 添加元素5到可变集中
3. 添加元素6, 7, 8到可变集中
4. 从可变集中移除元素1
5. 从可变集中移除元素3, 5, 7
6. 打印结果.

参考代码

//案例: 演示可变集.
object ClassDemo18 {
def main(args: Array[String]): Unit = {
//1. 定义一个可变集，包含以下元素: 1,2,3, 4
val set1 = Set(1, 2, 3, 4)
//2. 添加元素5到可变集中
set1 += 5
//3. 添加元素6, 7, 8到可变集中
//set1 ++= Set(6, 7, 8)
set1 ++= List(6, 7, 8) //两种写法均可.
//4. 从可变集中移除元素1
set1 -= 1
//5. 从可变集中移除元素3, 5, 7
//set1 --= Set(3, 5, 7)
set1 --= List(3, 5, 7) //两种写法均可.
//6. 打印结果.
println(set1)
}
}

需求

1. 定义一个可变集，包含以下元素: 1,2,3, 4
2. 添加元素5到可变集中
3. 添加元素6, 7, 8到可变集中
4. 从可变集中移除元素1
5. 从可变集中移除元素3, 5, 7
6. 打印结果.

参考代码

//案例: 演示可变集.
object ClassDemo18 {
def main(args: Array[String]): Unit = {
//1. 定义一个可变集，包含以下元素: 1,2,3, 4
val set1 = Set(1, 2, 3, 4)
//2. 添加元素5到可变集中
set1 += 5
//3. 添加元素6, 7, 8到可变集中
//set1 ++= Set(6, 7, 8)
set1 ++= List(6, 7, 8) //两种写法均可.
//4. 从可变集中移除元素1
set1 -= 1
//5. 从可变集中移除元素3, 5, 7
//set1 --= Set(3, 5, 7)
set1 --= List(3, 5, 7) //两种写法均可.
//6. 打印结果.
println(set1)
}
}