Scala的数组，元组，列表，集，映射（Map），迭代器(iterator)

已于 2023-03-28 21:05:06 修改
阅读量1k 收藏 3
点赞数 1
分类专栏： Spark 文章标签： scala 开发语言 后端 spark
于 2023-03-28 13:33:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73856491/article/details/129800667
版权

文章目录

1. 数组

1.1 概述

数组就是用来存储多个同类型元素的容器, 每个元素都有编号(也叫: 下标, 脚标, 索引), 且编号都是从0开始数的.
Scala中, 有两种数组，一种是定长数组，另一种是变长数组.

1.2 定长数组

1.2.1 特点

  1. 数组的长度不允许改变.
  2. 数组的内容是可变的.

1.2.2 语法

  • 格式一: 通过指定长度定义数组
val/var 变量名 = new Array[元素类型](数组长度)
  • 格式二: 通过指定元素定义数组
val/var 变量名 = Array(元素1, 元素2, 元素3...)

注意:

  1. 在scala中，数组的泛型使用 [] 来指定.
  2. 使用 数组名(索引) 来获取数组中的元素.
  3. 数组元素是有默认值的, Int:0, Double:0.0, String: null
  4. 通过 数组名.length 或者 数组名.size 来获取数组的长度.

1.2.3 示例

需求

  1. 定义一个长度为10的整型数组, 设置第1个元素为11, 并打印第1个元素.
  2. 定义一个包含"java", “scala”, "python"这三个元素的数组, 并打印数组长度.

参考代码

object ClassDemo01 {
def main(args: Array[String]): Unit = {
//1. 定义一个长度为10的整型数组, 设置第1个元素为11, 并打印第1个元素.
val arr1 = new Array[Int](10)
arr1(0) = 11
println(arr1(0)) //打印数组的第1个元素.
println("-" * 15) //分割线
//2. 定义一个包含"java", "scala", "python"这三个元素的数组, 并打印数组长度.
val arr2 = Array("java", "scala", "python")
println(arr2.length) //打印数组的长度
}
}

1.3 变长数组

1.3.1 特点

  • 数组的长度和内容都是可变的，可以往数组中添加、删除元素.

1.3.2 语法

  • 创建变长数组，需要先导入ArrayBuffer类.
import scala.collection.mutable.ArrayBuffer
  • 定义格式一: 创建空的ArrayBuffer变长数组
val/var 变量名 = ArrayBuffer[元素类型]()
  • 定义格式二: 创建带有初始元素的ArrayBuffer变长数组
val/var 变量名 = ArrayBuffer(元素1，元素2，元素3....)

1.3.3 示例一: 定义变长数组

  1. 定义一个长度为0的整型变长数组.
  2. 定义一个包含"hadoop", “storm”, "spark"这三个元素的变长数组.
  3. 打印结果.

参考代码

//1. 导包.
import scala.collection.mutable.ArrayBuffer

object ClassDemo02 {
	def main(args: Array[String]): Unit = {
	//2. 定义一个长度为0的整型变长数组.
		val arr1 = new ArrayBuffer[Int]()
		println("arr1:" + arr1)
		//3. 定义一个包含"hadoop", "storm", "spark"这三个元素的变长数组.
		val arr2 = ArrayBuffer("hadoop", "storm", "spark")
		println("arr2:" + arr2)
	}
}

1.3.4 示例二: 增删改元素

针对Scala中的变长数组, 可通过下述方式来修改数组中的内容.

格式

  • 使用 += 添加单个元素
  • 使用 -= 删除单个元素
  • 使用 ++= 追加一个数组到变长数组中
  • 使用 --= 移除变长数组中的指定多个元素

示例

  1. 定义一个变长数组，包含以下元素: “hadoop”, “spark”, “flink”
  2. 往该变长数组中添加一个"flume"元素
  3. 从该变长数组中删除"hadoop"元素
  4. 将一个包含"hive", "sqoop"元素的数组, 追加到变长数组中.
  5. 从该变长数组中删除"sqoop", "spark"这两个元素.
  6. 打印数组, 查看结果.

参考代码

//导包
import scala.collection.mutable.ArrayBuffer

object ClassDemo03 {
def main(args: Array[String]): Unit = {
//1. 定义一个变长数组，包含以下元素: "hadoop", "spark", "flink"
val arr = ArrayBuffer("hadoop", "spark", "flink")
//2. 往该变长数组中添加一个"flume"元素
arr += "flume"
//3. 从该变长数组中删除"hadoop"元素
arr -= "hadoop"
//4. 将一个包含"hive", "sqoop"元素的数组, 追加到变长数组中.
arr ++= Array("hive", "sqoop")
//5. 从该变长数组中删除"sqoop", "spark"这两个元素.
arr --= Array("sqoop", "spark")
//6. 打印数组, 查看结果.
println(s"arr: ${arr}")
}
}

1.4 遍历数组

概述
在Scala中, 可以使用以下两种方式来遍历数组：
1. 使用 索引 遍历数组中的元素
2. 使用 for表达式 直接遍历数组中的元素

示例
1. 定义一个数组，包含以下元素1,2,3,4,5
2. 通过两种遍历方式遍历数组，并打印数组中的元素

参考代码

object ClassDemo04 {
def main(args: Array[String]): Unit = {
//1. 定义一个数组，包含以下元素1,2,3,4,5
val arr = Array(1, 2, 3, 4, 5)
//2. 通过两种遍历方式遍历数组，并打印数组中的元素.
//方式一: 遍历索引的形式实现.
for(i <- 0 to arr.length -1) println(arr(i))
println("-" * 15) //分割线
for(i <- 0 until arr.length) println(arr(i))
println("-" * 15) //分割线
//方式二: 直接遍历数组元素.
for(i <- arr) println(i)
}
}

注意:
0 until n 获取0~n之间的所有整数, 包含0, 不包含n.
0 to n 获取0~n之间的所有整数, 包含0, 也包含n.

1.5 数组常用算法

概述
Scala中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现, 而是可以直接拿来用。

以下为常用的几个算法：

  • sum()方法: 求和
  • max()方法: 求最大值
  • min()方法: 求最小值
  • sorted()方法: 排序, 返回一个新的数组.
  • reverse()方法: 反转, 返回一个新的数组.

需求

  1. 定义一个数组, 包含4, 1, 6, 5, 2, 3这些元素.
  2. 在main方法中, 测试上述的常用算法.

参考代码

object ClassDemo05 {
def main(args: Array[String]): Unit = {
//1. 定义一个数组, 包含4, 1, 6, 5, 2, 3这些元素.
val arr = Array(4, 1, 6, 5, 2, 3)
//2. 在main方法中, 测试上述的常用算法.
//测试sum
println(s"sum: ${arr.sum}")
//测试max
println(s"max: ${arr.max}")
//测试min
println(s"min: ${arr.min}")
//测试sorted
val arr2 = arr.sorted //即: arr2的内容为:1, 2, 3, 4, 5, 6
//测试reverse
val arr3 = arr.sorted.reverse //即: arr3的内容为: 6, 5, 4, 3, 2, 1
//3. 打印数组.
for(i <- arr) println(i)
println("-" * 15)
for(i <- arr2) println(i)
println("-" * 15)
for(i <- arr3) println(i)
}
}

2. 元组

元组一般用来存储多个不同类型的值。例如同时存储姓名，年龄，性别，出生年月这些数据, 就要用到元组来存储
了。并且**元组的长度和元素都是不可变的。**

2.1 格式

  • 格式一: 通过小括号实现
val/var 元组 = (元素1, 元素2, 元素3....)
  • 格式二: 通过箭头来实现
val/var 元组 = 元素1->元素2

注意: 上述这种方式, 只适用于元组中只有两个元素的情况.

2.2 示例

需求

  1. 定义一个元组，包含学生的姓名和年龄.
  2. 分别使用小括号以及箭头的方式来定义元组.

参考代码

object ClassDemo06 {
def main(args: Array[String]): Unit = {
//1. 定义一个元组，包含学生的姓名和年龄.
//2. 分别使用小括号以及箭头的方式来定义元组.
val tuple1 = ("张三", 23)
val tuple2 = "张三" -> 23
println(tuple1)
println(tuple2)
}
}

2.3 访问元组中的元素

在Scala中, 可以通过 元组名._编号 的形式来访问元组中的元素，_1表示访问第一个元素，依次类推.
也可以通过 元组名.productIterator 的方式, 来获取该元组的迭代器, 从而实现遍历元组.

格式

  • 格式一: 访问元组中的单个元组.
println(元组名._1) //打印元组的第一个元素.
println(元组名._2) //打印元组的第二个元组.
...
  • 格式二: 遍历元组
val tuple1 = (值1, 值2, 值3, 值4, 值5...) //可以有多个值
val it = tuple1.productIterator //获取当前元组的迭代器对象
for(i <- it) println(i) //打印元组中的所有内容.

示例

  1. 定义一个元组，包含一个学生的姓名和性别，“zhangsan”, “male”
  2. 分别获取该学生的姓名和性别, 并将结果打印到控制台上.

参考代码

object ClassDemo07 {
def main(args: Array[String]): Unit = {
//1. 定义一个元组，包含一个学生的姓名和性别，"zhangsan", "male"
val tuple1 = "zhangsan" -> "male"
//2. 分别获取该学生的姓名和性别
//方式一: 通过 _编号 的形式实现.
println(s"姓名: ${tuple1._1}, 性别: ${tuple1._2}")
//方式二: 通过迭代器遍历的方式实现.
//获取元组对应的迭代器对象.
val it = tuple1.productIterator
//遍历元组.
for(i <- it) println(i)
}
}

3. 列表

列表(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 可变列表的常用操作

关于可变列表的常见操作如下:
在这里插入图片描述
示例

  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 格式详解

在实际开发中, 我们经常要操作列表, 以下列举的是列表的常用的操作:
在这里插入图片描述

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)
}
}

注意，如果两个列表长度不一样，zip会删除多余的项

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. 集

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 概述

可变集指的是元素, 集的长度都可变, 它的创建方式和不可变集的创建方式一致，只不过需要先导入可变集类或者**val set1 = mutable.Set(元素,元素,..........)**。
手动导入： 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)
}
}

5. 映射

映射指的就是Map。它是由键值对(key, value)组成的集合。特点是: 键具有唯一性, 但是值可以重复. 在Scala中，Map也分为不可变Map和可变Map。

注意: 如果添加重复元素(即: 两组元素的键相同), 则 会用新值覆盖旧值 .

5.1 不可变Map

不可变Map指的是元素, 长度都不可变.
语法

  • 方式一: 通过箭头的方式实现.
val/var map = Map(键->值, 键->值, 键->值...) // 推荐，可读性更好
  • 方式二: 通过 小括号 的方式实现.
val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)

需求

  1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24, 李四 -> 40
  2. 打印结果.

参考代码

object ClassDemo19 {
def main(args: Array[String]): Unit = {
//1. 定义一个映射，包含以下学生姓名和年龄数据.
val map1 = Map("张三" -> 23, "李四" -> 24, "李四" -> 40)
val map2 = Map(("张三", 23),("李四", 24), ("李四" -> 40))
//2. 打印结果.
println(s"map1: ${map1}")
println(s"map2: ${map2}")
}
}

5.2 可变Map

特点
可变Map指的是元素, 长度都可变. 定义语法与不可变Map一致, 只不过需要先手动导包:
import scala.collection.mutable.Map
或者val map1 = mutable.Map("张三" -> 23, "李四" -> 24)
需求

  1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
  2. 修改张三的年龄为30
  3. 打印结果

参考代码

import scala.collection.mutable.Map

object ClassDemo20 {
def main(args: Array[String]): Unit = {
//1. 定义一个映射，包含以下学生姓名和年龄数据.
val map1 = Map("张三" -> 23, "李四" -> 24)
val map2 = Map(("张三", 23),("李四", 24))
//2. 修改张三的年龄为30
map1("张三") = 30
//3. 打印结果
println(s"map1: ${map1}")
println(s"map2: ${map2}")
}
}

5.3 Map基本操作

格式

  1. map(key) : 根据键获取其对应的值, 键不存在返回None.
  2. map.keys : 获取所有的键.
  3. map.values : 获取所有的值.
  4. 遍历map集合: 可以通过普通for实现.
  5. getOrElse: 根据键获取其对应的值, 如果键不存在, 则返回指定的默认值.
  6. +号 : 增加键值对, 并生成一个新的Map.

注意: 如果是可变Map, 则可以通过 +=或者++= 直接往该可变Map中添加键值对元素.

  1. -号 : 根据键删除其对应的键值对元素, 并生成一个新的Map.

注意: 如果是可变Map, 则可以通过-=或者--=直接从该可变Map中删除键值对元素.

示例

  1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
  2. 获取张三的年龄, 并打印.
  3. 获取所有的学生姓名, 并打印.
  4. 获取所有的学生年龄, 并打印.
  5. 打印所有的学生姓名和年龄.
  6. 获取 王五 的年龄，如果 王五 不存在，则返回-1, 并打印.
  7. 新增一个学生：王五, 25, 并打印结果.
  8. 将 李四 从可变映射中移除, 并打印.

参考代码

import scala.collection.mutable.Map

object ClassDemo21 {
def main(args: Array[String]): Unit = {
//1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
val map1 = Map("张三" -> 23, "李四" -> 24)
//2. 获取张三的年龄, 并打印.
println(map1.get("张三"))
//3. 获取所有的学生姓名, 并打印.
println(map1.keys)
//4. 获取所有的学生年龄, 并打印.
println(map1.values)
//5. 打印所有的学生姓名和年龄.
for((k, v) <- map1) println(s"键:${k}, 值:${v}")
println("-" * 15)
//6. 获取`王五`的年龄，如果`王五`不存在，则返回-1, 并打印.
println(map1.getOrElse("王五", -1))
println("-" * 15)
//7. 新增一个学生：王五, 25, 并打印结果.
/*//不可变Map
val map2 = map1 + ("王五" -> 25)
println(s"map1: ${map1}")
println(s"map2: ${map2}")*/
map1 += ("王五" -> 25)
//8. 将`李四`从可变映射中移除, 并打印.
map1 -= "李四"
println(s"map1: ${map1}")
}
}

6. 迭代器(iterator)

6.1 概述

Scala针对每一类集合都提供了一个迭代器(iterator), 用来迭代访问集合.

6.2 注意事项

  1. 使用 iterator 方法可以从集合获取一个迭代器.

迭代器中有两个方法:
hasNext方法: 查询容器中是否有下一个元素
next方法: 返回迭代器的下一个元素，如果没有，抛出NoSuchElementException

  1. 每一个迭代器都是有状态的.

即: 迭代完后保留在最后一个元素的位置. 再次使用则抛出NoSuchElementException

  1. 可以使用while或者for来逐个获取元素.

6.3 示例

需求

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

参考代码

object ClassDemo22 {
def main(args: Array[String]): Unit = {
//1. 定义一个列表，包含以下元素：1,2,3,4,5
val list1 = List(1, 2, 3, 4, 5)
//2. 使用while循环和迭代器，遍历打印该列表.
//2.1 根据列表获取其对应的迭代器对象.
val it = list1.iterator
//2.2 判断迭代器中是否有下一个元素.
while(it.hasNext){
//2.3 如果有, 则获取下一个元素, 并打印.
println(it.next)
}
//分割线.
println("-" * 15)
//迭代完后, 再次使用该迭代器获取元素, 则抛异常: NoSuchElementException
println(it.next)
}
}
Maverick_曲流觞
关注
专栏目录
Scala(10) -- scala的数组、元组、列表、集、映射、迭代器、函数式编程
erainm
09-21 548
1. 数组 2. 元组 3. 列表 4. 集 5. 映射 6. 迭代器(iterator) 7. 函数式编程 8. 案例
Scala 数组（Array）、列表（List）、集合（Set）、映射（Map）和元组（Tuple）
shangjg3的博客
10-31 240
在 Scala 中，如果你需要一个长度不变的数组，可以使用 Array。但需要注意以下两点： - 在 Scala 中使用 (index) 而不是 [index] 来访问数组中的元素，因为访问元素，对于 Scala 来说是方法调用，(index) 相当于执行了 .apply(index) 方法。 - Scala 中的数组与 Java 中的是等价的，Array[Int]() 在虚拟机层面就等价于 Java 的 int[]。
Scala对数组数据进行map(数据转换)操作
W2398439780的博客
04-20 455
首先,我们定义一个arrayOperation的函数,它的两个参数分别是需要传入的原数组和需要进行的数据操作函数 arrayOperation函数采用for循环对传入的数组进行遍历,将其中的元素用传入的函数进行数据操作并 yeild 生成一个新数组 接着,写一个带有数据的数组arr和一个数据操作函数addOne,将它们作为参数传给arrayOperation函数,完成对数据的map(数据转换)操作
【scala 迭代器】Scala Iterator（迭代器）
赖德发的博客
12-27 2586
1、Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。 2、迭代器 it 的两个基本操作是 next 和 hasNext。 3、调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。 4、调用 it.hasNext() 用于检测集合中是否还有元素。 5、让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环。 6、你可以使用
scala iterator 转java_Scala Iterator（迭代器）
weixin_42512474的博客
02-28 233
序号方法及描述1def hasNext: Boolean如果还有可返回的元素，返回true。2def next(): A返回迭代器的下一个元素，并且更新迭代器的状态3def ++(that: => Iterator[A]): Iterator[A]合并两个迭代器4def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B]...
Scala Iterator（迭代器）
最新发布
lly202406的博客
06-21 440
Scala Iterator（迭代器）是一种用于访问集合元素序列的抽象数据类型。它提供了一种高效的方式来逐个访问集合中的元素，而不需要暴露其底层结构。Scala中的迭代器是不可变的，这意味着它们只能被单向遍历一次。一旦迭代器被消耗完，就不能再重新使用。
scala Iterator
weixin_33842328的博客
05-20 148
2019独角兽企业重金招聘Python工程师标准>>> ...
scala_数组、列表、元组、集合、map
Imflash的博客
09-21 777
文章目录数组定长数组定义变长数组添加/修改/删除元素求和最大值最小值排序元组定义元组访问元组定义示例一示例二示例三可变列表定义示例一示例二可变列表操作示例判断列表是否为空拼接两个列表获取列表的首个元素和剩余部分反转列表获取列表前缀和后缀扁平化(压平)拉链与拉开转换字符串生成字符串并集交集差集不可变集定义示例一示例二基本操作示例定义示例不可变Map定义示例可变Map定义示例Map基本操作基本操作示例...
day04-scala学习之数组、映射(Map)、元组(Tuple)
shenjinrui的博客
12-19 311
day03([day03-scala学习之函数参数、Lazy(懒值)、异常处理](https://blog.csdn.net/shenjinrui/article/details/103619324))，我们学习了scala函数参数、Lzay(懒值)、异常处理，今天学习scala的数组、映射(Map)、元组(Tuple)。
Scala数组基本方法的使用
May_J_Oldhu的博客
10-29 842
05.Scala数组基本方法 a: Array[Int] = Array(1, 2, 3, 4, 5, 6) 1.求数组元素的和: (0/:a)(_+_) a.aggregate(0)(_+_,_+_) a.fold(0)(_+_) a.reduce(_+_) (a.scan(0)(_+_)).apply(a.size) a.sum 2.求数组元素的积 (1/:a)(_*_) a.aggregate(1)(_*_,_*_) a.fold(1)(_*_) a.reduce(_*_) a.product
Scala语法(iterator迭代器)
01-08
iterator迭代器 scala针对每一类集合都提供了一个迭代器（iterator）用来迭代访问集合 使用迭代器遍历集合 使用iterator方法可以从集合获取一个迭代器 迭代器的两个基本操作 hasNext——查询容器中是否有下一个元素 next——返回迭代器的下一个元素，如果没有，抛出NoSuchElementException 每一个迭代器都是有状态的 迭代完后保留在最后一个元素的位置 再次使用则抛出NoSuchElementException 可以使用while或者for来逐个返回元素 示例: 1.定义一个列表，包含以下元素：1,2,3,4,5 2.使用while循环和迭代器，遍历打
Scala 迭代器
Simple 专栏
09-16 829
迭代器不是集合，而是一种逐个访问集合元素的方法。 下一个迭代器的两个基本操作是hasNext。 对it.next()方法的调用将返回迭代器的下一个元素，并提高迭代器的状态。可以使用Iterator的it.hasNext方法判断是否还有更多元素返回。 迭代器返回的所有元素最直接的方法是使用while循环。让我们参考以下示例程序 - 示例 object Demo { def main(a...
scala迭代器
m0_58535137的博客
02-13 217
object 迭代器 { def main(args: Array[String]): Unit = { val list = List(1, 2, 3, 4, 5, 6) val it = list.iterator while (it.hasNext) { print(it.next() + " ") } } }
scala中迭代器
sinat_23257429的博客
08-31 999
scala迭代器与其在spark 中的应用
【Scala】Iterator(迭代器)
依旧的博客
03-27 4690
Scala Iterator(迭代器) 不是一个集合,它是一种用于访问集合的方法 迭代器的It的两个基本操作是next 和 hasNext 调用 it.next() 会返回迭代器的下一个元素,并且更新迭代器的状态 调用 it.hasNext() 用于检测集合中是否还有元素 让迭代器it逐个返回所有元素最简单的方法是使用while循环 迭代器操作 注意: 每调用一次迭代器走完,迭代器就相当...
Scala迭代器iterator
hzp666的博客
03-31 684
1.定义： Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。 迭代器 it 的两个基本操作是next和hasNext。 调用it.next()会返回迭代器的下一个元素，并且更新迭代器的状态。 调用it.hasNext()用于检测集合中是否还有元素。 让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环： eg： var inter = Iterator(1, 2, 3, 4) while (inter.hasNext)...
Scala编程：元组与数组深度解析
"这篇文档主要介绍了Scala编程语言中关于Array和Map的基本概念和操作，包括元组、定长数组和变长数组的使用方法。" 在Scala中，Array和Map是两种常用的数据结构，它们各自有不同的特点和应用场景。 1. 元组（Tuple...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值