Scala集合和遍历

目录

1 列表

列表是scala中最重要的、也是最常用的数据结构。List具备以下性质：

  • 可以保存重复的值
  • 有先后顺序

在scala中，也有两种列表，一种是不可变列表、另一种是可变列表

1.1 定义

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

语法

使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表，语法格式：

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

使用Nil创建一个不可变的空列表

val/var 变量名 = Nil

使用::方法创建一个不可变列表

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

[TIP]

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

1.1.1 示例一

创建一个不可变列表，存放以下几个元素（1,2,3,4）

参考代码

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

1.1.2 示例二

使用Nil创建一个不可变的空列表

参考代码

scala> val a = Nil
a: scala.collection.immutable.Nil.type = List()

1.1.3 示例三

使用::方法创建列表，包含-2、-1两个元素

参考代码

scala> val a = -2 :: -1 :: Nil
a: List[Int] = List(-2, -1)

2 可变列表

可变列表就是列表的元素、长度都是可变的。

要使用可变列表，先要导入import scala.collection.mutable.ListBuffer

[NOTE]

  • 可变集合都在mutable包中
  • 不可变集合都在immutable包中（默认导入）

2.1 定义

使用ListBuffer[元素类型]()创建空的可变列表，语法结构：

val/var 变量名 = ListBuffer[Int]()

使用ListBuffer(元素1, 元素2, 元素3…)创建可变列表，语法结构：

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

2.1.1 示例一

创建空的整形可变列表

参考代码

  scala> val a = ListBuffer[Int]()
  a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

2.1.2 示例二

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

参考代码

scala> val a = ListBuffer(1,2,3,4)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

2.2 可变列表操作

  • 获取元素（使用括号访问(索引值)）
  • 添加元素（+=）
  • 追加一个列表（++=）
  • 更改元素（使用括号获取元素，然后进行赋值）
  • 删除元素（-=）
  • 转换为List（toList）
  • 转换为Array（toArray）

2.2.1 示例

  1. 定义一个可变列表包含以下元素：1,2,3
  2. 获取第一个元素
  3. 添加一个新的元素：4
  4. 追加一个列表，该列表包含以下元素：5,6,7
  5. 删除元素7
  6. 将可变列表转换为不可变列表
  7. 将可变列表转换为数组

参考代码

// 导入不可变列表
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer

// 创建不可变列表
scala> val a = ListBuffer(1,2,3)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)

// 获取第一个元素
scala> a(0)
res19: Int = 1

// 追加一个元素
scala> a += 4
res20: a.type = ListBuffer(1, 2, 3, 4)

// 追加一个列表
scala> a ++= List(5,6,7)
res21: a.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)

// 删除元素
scala> a -= 7
res22: a.type = ListBuffer(1, 2, 3, 4, 5, 6)

// 转换为不可变列表
scala> a.toList
res23: List[Int] = List(1, 2, 3, 4, 5, 6)

// 转换为数组
scala> a.toArray
res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)

3 列表常用操作

以下是列表常用的操作

  • 判断列表是否为空（isEmpty）
  • 拼接两个列表（++）
  • 获取列表的首个元素（head）和剩余部分(tail)
  • 反转列表（reverse）
  • 获取前缀（take）、获取后缀（drop）
  • 扁平化（flaten）
  • 拉链（zip）和拉开（unzip）
  • 转换字符串（toString）
  • 生成字符串（mkString）
  • 并集（union）
  • 交集（intersect）
  • 差集（diff）

3.1 判断列表是否为空

示例

  • 定义一个列表，包含以下元素：1,2,3,4
  • 使用isEmpty判断列表是否为空

参考代码

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> a.isEmpty
res51: Boolean = false

3.2 拼接两个列表

示例

  • 有两个列表，分别包含以下元素1,2,3和4,5,6
  • 使用++将两个列表拼接起来

参考代码

scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)

scala> val b = List(4,5,6)
b: List[Int] = List(4, 5, 6)

scala> a ++ b
res52: List[Int] = List(1, 2, 3, 4, 5, 6)

3.3 获取列表的首个元素和剩余部分

示例

  • 定义一个列表，包含以下几个元素：1,2,3
  • 使用head方法，获取列表的首个元素
  • 使用tail方法，获取除第一个元素以外的元素，它也是一个列表

参考代码

scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)

scala> a.head
res4: Int = 1

scala> a.tail
res5: List[Int] = List(2, 3)

3.4 反转列表

示例

  • 定一个列表，包含以下元素：1,2,3

  • 使用reverse方法将列表的元素反转

scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)

scala> a.reverse
res6: List[Int] = List(3, 2, 1)

3.5 获取列表前缀和后缀

示例

  • 定义一个列表，包含以下元素：1,2,3,4,5
  • 使用take方法获取前缀（前三个元素）：1,2, 3
  • 使用drop方法获取后缀（除前三个以外的元素）：4,5

参考代码

scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)

scala> a.take(3)
res56: List[Int] = List(1, 2, 3)

scala> a.drop(3)
res60: List[Int] = List(4, 5)

3.6 扁平化(压平)

扁平化表示将列表中的列表中的所有元素放到一个列表中。

在这里插入图片描述

示例

  • 有一个列表，列表中又包含三个列表，分别为：List(1,2)、List(3)、List(4,5)
  • 使用flatten将这个列表转换为List(1,2,3,4,5)

参考代码

scala> val a = List(List(1,2), List(3), List(4,5))
a: List[List[Int]] = List(List(1, 2), List(3), List(4, 5))

scala> a.flatten
res0: List[Int] = List(1, 2, 3, 4, 5)

3.7 拉链与拉开

  • 拉链：使用zip将两个列表，组合成一个元素为元组的列表
  • 拉开：将一个包含元组的列表，解开成包含两个列表的元组

示例

  • 有两个列表
    • 第一个列表保存三个学生的姓名，分别为：zhangsan、lisi、wangwu
    • 第二个列表保存三个学生的年龄，分别为：19, 20, 21
  • 使用zip操作将两个列表的数据"拉"在一起，形成 zhangsan->19, lisi ->20, wangwu->21

参考代码

scala> val a = List("zhangsan", "lisi", "wangwu")
a: List[String] = List(zhangsan, lisi, wangwu)

scala> val b = List(19, 20, 21)
b: List[Int] = List(19, 20, 21)

scala> a.zip(b)
res1: List[(String, Int)] = List((zhangsan,19), (lisi,20), (wangwu,21))

示例

  • 将上述包含学生姓名、年龄的元组列表，解开成两个列表

参考代码

scala> res1.unzip
res2: (List[String], List[Int]) = (List(zhangsan, lisi, wangwu),List(19, 20, 21))

3.8 转换字符串

toString方法可以返回List中的所有元素

示例

  • 定义一个列表，包含以下元素：1,2,3,4
  • 使用toString输出该列表的元素

参考代码

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> println(a.toString)
List(1, 2, 3, 4)

3.9 生成字符串

mkString方法，可以将元素以分隔符拼接起来。默认没有分隔符

示例

  • 定义一个列表，包含以下元素1,2,3,4
  • 使用mkString，用冒号将元素都拼接起来

参考代码

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> a.mkString
res7: String = 1234

scala> a.mkString(":")
res8: String = 1:2:3:4

3.10 并集

union表示对两个列表取并集，不去重

示例

  • 定义第一个列表，包含以下元素：1,2,3,4
  • 定义第二个列表，包含以下元素：3,4,5,6
  • 使用union操作，获取这两个列表的并集
  • 使用distinct操作，去除重复的元素

参考代码

scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)

scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)

// 并集操作
scala> a1.union(a2)
res17: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6)

// 可以调用distinct去重
scala> a1.union(a2).distinct
res18: List[Int] = List(1, 2, 3, 4, 5, 6)

3.11 交集

intersect表示对两个列表取交集

示例

  • 定义第一个列表，包含以下元素：1,2,3,4
  • 定义第二个列表，包含以下元素：3,4,5,6
  • 使用intersect操作，获取这两个列表的交集
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)

scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)

scala> a1.intersect(a2)
res19: List[Int] = List(3, 4)

3.12 差集

diff表示对两个列表取差集，例如： a1.diff(a2)，表示获取a1在a2中不存在的元素

示例

  • 定义第一个列表，包含以下元素：1,2,3,4
  • 定义第二个列表，包含以下元素：3,4,5,6
  • 使用diff获取这两个列表的差集
scala> val a1 = List(1,2,3,4)
a1: List[Int] = List(1, 2, 3, 4)

scala> val a2 = List(3,4,5,6)
a2: List[Int] = List(3, 4, 5, 6)

scala> a1.diff(a2)
res24: List[Int] = List(1, 2)

4 Set

Set(集)是代表没有重复元素的集合。Set具备以下性质：

  1. 元素不重复
  2. 不保证插入顺序

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

4.1 不可变集

4.1.1 定义

语法

创建一个空的不可变集，语法格式：

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

给定元素来创建一个不可变集，语法格式：

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

4.1.2 示例一

定义一个空的不可变集

参考代码

scala> val a = Set[Int]()
a: scala.collection.immutable.Set[Int] = Set()

4.1.3 示例二

定义一个不可变集，保存以下元素：1,1,3,2,4,8

参考代码

scala> val a = Set(1,1,3,2,4,8)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 8, 4)

4.1.4 基本操作

  • 获取集的大小（size）
  • 遍历集（和遍历数组一致）
  • 添加一个元素，生成一个Set（+）
  • 拼接两个集，生成一个Set（++）
  • 拼接集和列表，生成一个Set（++）

4.1.5 示例

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

参考代码

// 创建集
scala> val a = Set(1,1,2,3,4,5)
a: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

// 获取集的大小
scala> a.size
res0: Int = 5

// 遍历集
scala> for(i <- a) println(i)

// 删除一个元素
scala> a - 1
res5: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)

// 拼接两个集
scala> a ++ Set(6,7,8)
res2: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)

// 拼接集和列表
scala> a ++ List(6,7,8,9)
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

5 可变集

5.1 定义

可变集合不可变集的创建方式一致，只不过需要提前导入一个可变集类。

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

5.1.1 示例

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

参考代码

scala> val a = Set(1,2,3,4)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4)                          

// 添加元素
scala> a += 5
res25: a.type = Set(1, 5, 2, 3, 4)

// 删除元素
scala> a -= 1
res26: a.type = Set(5, 2, 3, 4)

6 映射

Map可以称之为映射。它是由键值对组成的集合。在scala中，Map也分为不可变Map和可变Map。

6.1 不可变Map

6.1.1 定义

语法

val/var map = Map(键->值, 键->值, 键->值...)	// 推荐，可读性更好
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)

6.1.2 示例

  1. 定义一个映射，包含以下学生姓名和年龄数据

    "zhangsan", 30
"lisi", 40

  2. 获取zhangsan的年龄

参考代码

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

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

// 根据key获取value
scala> map("zhangsan")
res10: Int = 30

6.2 可变Map

6.2.1 定义

定义语法与不可变Map一致。但定义可变Map需要手动导入import scala.collection.mutable.Map

6.2.2 示例

  1. 定义一个映射，包含以下学生姓名和年龄数据

    "zhangsan", 30
"lisi", 40

  2. 修改zhangsan的年龄为20

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

// 修改value
scala> map("zhangsan") = 20

7 Map基本操作

7.1 基本操作

  • 获取值(map(key))
  • 获取所有key（map.keys）
  • 获取所有value（map.values）
  • 遍历map集合
  • getOrElse
  • 增加key,value对
  • 删除key

7.2 示例

  1. 定义一个映射，包含以下学生姓名和年龄数据

    "zhangsan", 30
"lisi", 40

  2. 获取zhangsan的年龄

  3. 获取所有的学生姓名

  4. 获取所有的学生年龄

  5. 打印所有的学生姓名和年龄

  6. 获取wangwu的年龄，如果wangwu不存在，则返回-1

  7. 新增一个学生：wangwu, 35

  8. 将lisi从可变映射中移除

参考代码

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

// 获取zhagnsan的年龄
scala> map("zhangsan")
res10: Int = 30

// 获取所有的学生姓名
scala> map.keys
res13: Iterable[String] = Set(lisi, zhangsan)

// 获取所有的学生年龄
scala> map.values
res14: Iterable[Int] = HashMap(40, 30)

// 打印所有的学生姓名和年龄
scala> for((x,y) <- map) println(s"$x $y")
lisi 40
zhangsan 30

// 获取wangwu的年龄，如果wangwu不存在，则返回-1
scala> map.getOrElse("wangwu", -1)
res17: Int = -1

// 新增一个学生：wangwu, 35
scala> map + "wangwu"->35
res22: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, wangwu -> 35)

// 将lisi从可变映射中移除
scala> map - "lisi"
res23: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)

8 iterator迭代器

scala针对每一类集合都提供了一个迭代器（iterator）用来迭代访问集合

8.1 使用迭代器遍历集合

  • 使用iterator方法可以从集合获取一个迭代器
  • 迭代器的两个基本操作
    • hasNext——查询容器中是否有下一个元素
    • next——返回迭代器的下一个元素，如果没有，抛出NoSuchElementException
  • 每一个迭代器都是有状态的
    • 迭代完后保留在最后一个元素的位置
    • 再次使用则抛出NoSuchElementException
  • 可以使用while或者for来逐个返回元素

8.2 示例

  1. 定义一个列表，包含以下元素：1,2,3,4,5
  2. 使用while循环和迭代器，遍历打印该列表

参考代码

scala> val ite = a.iterator
ite: Iterator[Int] = non-empty iterator

scala> while(ite.hasNext) {
     | println(ite.next)
     | }

示例

  1. 定义一个列表，包含以下元素：1,2,3,4,5
  2. 使用for 表达式和迭代器，遍历打印该列表

参考代码

scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)

scala> for(i <- a) println(i)
posted @ 2021-06-30 20:36  赵广陆  阅读(246)  评论(0)  编辑  收藏  举报