★ Scala ★ —— 数据结构与函数式编程（列表、元组、数组）

骑猪看日落 2022-10-29 09:20 51阅读 0赞

### 数据结构与函数式编程 ###

*   *   *  1.1 概述
         *  1.2 定长数组
         *   *  1.2.1 特点
             *  1.2.2 语法
         *  1.3 变长数组
         *   *  1.3.1 特点
             *  1.3.2 语法
         *  1.4 增删改元素
         *  1.5 遍历数组
         *  1.6 数组常用算法
         *  2. 元组
         *   *  2.1 格式
             *  2.2 访问元组中的元素
         *  3. 列表
         *   *  3.1 不可变列表
             *  3.2 可变列表
             *  3.3 可变列表的常用操作
             *  3.4 列表的常用操作
             *  3.5 扁平化(压平)
             *  3.6 列表转字符串
             *  3.6 并集, 交集, 差集

章节目标

1.  掌握数组, 元组相关知识点
2.  掌握列表, 集, 映射相关知识点
3.  了解迭代器的用法
4.  掌握函数式编程相关知识点
5.  掌握学生成绩单案例

### 1.1 概述 ###

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

### 1.2 定长数组 ###

#### 1.2.1 特点 ####

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

#### 1.2.2 语法 ####

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

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

### 1.3 变长数组 ###

#### 1.3.1 特点 ####

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

#### 1.3.2 语法 ####

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

### 1.4 增删改元素 ###

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

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

### 1.5 遍历数组 ###

**概述**  
在Scala中, 可以使用以下两种方式来遍历数组：

1.  使用 索引 遍历数组中的元素
2.  使用 for表达式 直接遍历数组中的元素

### 1.6 数组常用算法 ###

**概述**  
Scala中的数组封装了一些常用的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现, 而是可以直接  
拿来用。以下为常用的几个算法：  
sum()方法: 求和  
max()方法: 求最大值  
min()方法: 求最小值  
sorted()方法: 排序, 返回一个新的数组.  
reverse()方法: 反转, 返回一个新的数组

package Data_Structure
    
    object ClassDemo1 {
      def main(args: Array[String]): Unit = {
    
        // 定义一个定长数组, 包含4, 1, 6, 5, 2, 3这些元素.
        val arr = Array(4, 1, 6, 5, 2, 3)
        println(s"sum: ${arr.sum}, max: ${arr.max}, min: ${arr.min}")
        // 测试 sort
        var arr2 = arr.sorted // 即: arr2的内容为:1, 2, 3, 4, 5, 6
        // 测试 reverse
        var arr3 = arr.sorted.reverse // 即: arr3的内容为: 6, 5, 4, 3, 2, 1
    
        // 遍历打印数组
        for (i <- arr)
          println(i)
        println("-" * 15)
        for (i <- arr2)
          println(i)
        println("-" * 15)
        for (i <- arr3)
          println(i)
    
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]

package Data_Structure
    import scala.collection.mutable.ArrayBuffer
    
    object ClassDemo2 {
      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. 打印数组, 查看结果 flink, flume, hive
        println(s"arr: ${arr}")
      }
    }

![在这里插入图片描述][20210211115258318.png]

### 2. 元组 ###

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

#### 2.1 格式 ####

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

#### 2.2 访问元组中的元素 ####

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

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

### 3. 列表 ###

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

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

package Data_Structure
    
    object ClassDemo3 {
      def main(args: Array[String]): Unit = {
        // 1. 定义一个元组
        val tuple1 = ("张三", "male", "小红", "female")
        // 2. 分别获取该学生的姓名和性别
        println(s"姓名: ${tuple1._1}, 性别: ${tuple1._2}")
        // 获取元组对应的迭代器对象
        val it = tuple1.productIterator
        // 遍历元组
        for(i <- it) println(i)
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]

#### 3.1 不可变列表 ####

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

**语法：**

格式一: 通过 小括号 直接初始化
    val/var 变量名 = List(元素1, 元素2, 元素3...)
    
    格式二: 通过 Nil 创建一个空列表
    val/var 变量名 = Nil
    
    格式三: 使用 :: 方法实现
    val/var 变量名 = 元素1 :: 元素2 :: Nil
    注意: 使用::拼接方式来创建列表，必须在最后添加一个Nil

#### 3.2 可变列表 ####

**特点：** 可变列表指的是列表的元素、长度都是可变的  
**语法：** 要使用可变列表, 必须先导包

import scala.collection.mutable.ListBuffer
    格式一: 创建空的可变列表
    val/var 变量名 = ListBuffer[数据类型]()
    
    格式二: 通过 小括号 直接初始化
    val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

#### 3.3 可变列表的常用操作 ####

关于可变列表的常见操作如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 2]

#### 3.4 列表的常用操作 ####

**格式详解：**  
在实际开发中, 我们经常要操作列表, 以下列举的是列表的常用的操作：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 3]

package Data_Structure
    
    import scala.collection.mutable.ListBuffer
    
    object ClassDemo4 {
      def main(args: Array[String]): Unit = {
        // 1. 定义一个可变列表包含以下元素：1,2,3
        val list1 = ListBuffer(1, 2, 3)
        // 2. 获取第一个元素, 并打印结果到控制台.
        println("第一个元素：",list1(0))
        // 3. 添加一个新的元素：
        list1 += 4
        //4. 追加一个列表
        list1 ++= List(5, 6, 7, 8, 9)
        //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"是否为isEmpty：${list1.isEmpty}," +
          s"\t 首个元素：${list1.head},\t 其他元素：${list1.tail}")
    
        println(s"元素反转：${list1.reverse};\n元素前缀${list1.take(2)};\n元素后缀${list1.drop(3)}")
    
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 4]

#### 3.5 扁平化(压平) ####

**概述：** 扁平化表示将嵌套列表中的所有具体元素单独的放到一个新列表中。

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

#### 3.6 列表转字符串 ####

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

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

package Data_Structure
    
    object ClassDemo5 {
      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)
    
        //  使用toString方法输出该列表的元素
        println(list1.toString)
        println("-" * 15)
        // 3. 使用mkString方法, 用冒号将元素都拼接起来, 并打印结果.
        println(list1.mkString(":"))
    
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 5]

#### 3.6 并集, 交集, 差集 ####

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

*  **union: 表示对两个列表取并集，而且不去重**  
    例如: list1.union(list2), 表示获取list1和list2中所有的元素(元素不去重).  
    如果想要去除重复元素, 则可以通过 distinct 实现.
 *  **intersect: 表示对两个列表取交集**  
    例如: list1.intersect(list2), 表示获取list1, list2中都有的元素
 *  **diff: 表示对两个列表取差集**  
    例如：list1.diff(list2)，表示获取list1中有, 但是list2中没有的元素

package Data_Structure
    
    object ClassDemo6 {
      def main(args: Array[String]): Unit = {
        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)
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 6]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]: /images/20221024/f2dbdb3ada0d46cf9f909ca752b474f9.png
[20210211115258318.png]: /images/20221024/5576e0f21ab044d9be9026b925fff32c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]: /images/20221024/bb73d651134b467896c860955e677d0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 2]: /images/20221024/51f20787ad9b4eba9fe0fbaa8314051c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 3]: /images/20221024/98fc7e1938d745388879db3233b600fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 4]: /images/20221024/39c7b39710d54142b7674dea02ccf9df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 5]: /images/20221024/a7204dcf4176409abcd88dc93486866f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 6]: /images/20221024/b637ff8f3f864b34a4d92d9095c92264.png