Scala系列6：Scala中Array,BufferArray,元组，list，set，map等集合使用详解

电玩女神 2022-12-03 02:22 214阅读 0赞

**    Scala中集合类的序列有：数组，元组，列表，Set集，Map映射,其中数组，列表，Set,Map又分为可变和不可变两种。下面就此详细展开介绍使用。**

## **0.数组的使用详解** ##

**scala中数组的概念是和Java类似，可以用数组来存放一组数据。scala中，有两种数组，一种是定长数组，另一种是变长数组。**

### **0.1 定长数组** ###

**定长数组指的是数组的长度是不允许改变的**** 。通过指定长度定义数组，语法格式如下：**

*  val/var 变量名 = new Array\[元素类型\](数组长度) //**方式1： 通过指定长度定义数组**
 *  **val/var 变量名 = Array(元素1, 元素2, 元素3...) // 方式2：用元素直接初始化数组**

***尖叫提示：***

1.  **在scala中，数组的泛型使用 \[\] 来指定**
2.  **使用 () 来获取元素，角标从0开始。**

//1.通过初始化定义数组： 数组定义包含jave、scala、python三个元素的数组
    scala> val a = Array("java", "scala", "python")
    a: Array[String] = Array(java, scala, python)
    scala> a.length
    res17: Int = 3
    
    //注意，这种不同类型数据也可以创建到数组里，类型为Any。
    scala> val  a4=Array("a","b",1)
    a4: Array[Any] = Array(a, b, 1)
    
    //2.通过指定长度定义数组，这种指定类型的数组，只能赋值同类型的数据。
    scala> val a = new Array[Int](100)
    a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
    scala> a(0) = 110
    scala> println(a(0))
    110
    //注意：这种指定类型的数组，只能赋值同类型的数据。
    scala> a (1)=1
    scala> a(1)
    res13: Int = 1
    scala> a(2)="1b"
    <console>:16: error: type mismatch;
     found   : String("1b")
     required: Int
           a(2)="1b"
                ^

### 0.2 变长数组 ###

**变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素**

***\[1.语法格式\]：***

1.  **val/var a = ArrayBuffer\[元素类型\]()   //方式1：创建空的ArrayBuffer变长数组**
2.  **val/var a = ArrayBuffer(元素1，元素2，元素3....) //方式2：创建带有初始元素的ArrayBuffer**

***\[尖叫提示\]*  
创建变长数组，需要提前导入ArrayBuffer类 import scala.collection.mutable.ArrayBuffer**

scala> import scala.collection.mutable._
    import scala.collection.mutable._
    
    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)

***\[2.变长数组的操作\]***

*  **添加/修改/删除元素**
 *  **使用 += 添加元素**
 *  **使用 -= 删除元素**
 *  **使用 ++= 追加一个数组到变长数组**

// 1.定义变长数组
    scala> val a = ArrayBuffer("hadoop", "spark", "flink")
    a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)
    //2. 追加一个元素
    scala> a += "flume"
    res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)
    // 3.删除一个元素
    scala> a -= "hadoop"
    res11: a.type = ArrayBuffer(spark, flink, flume)
    // 4. 追加一个数组
    scala> a ++= Array("hive", "sqoop")
    res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)

### 0.3数组的其他操作（定长数组和变长数组） ###

*  **遍历数组方式1：使用 for表达式 直接遍历数组中的元素**
 *  **遍历数组方式2：使用 索引 遍历数组中的元素**
 *  **数组求和——sum方法**
 *  **数组求最大值——max方法**
 *  **数组求最小值——min方法**
 *  **数组排序——sorted方法**

//1.使用for直接遍历数组元素
    scala> val a = Array(1,2,3,4,5)
    a: Array[Int] = Array(1, 2, 3, 4, 5)
    scala> for(i<-a) println(i)
    1
    2
    3
    4
    5
    //2.使用for表达式基于索引下标遍历，并打印数组的元素
    scala> val a = Array(1,2,3,4,5)
    a: Array[Int] = Array(1, 2, 3, 4, 5)
    scala> for(i <- 0 to a.length - 1) println(a(i))
    1
    2
    3
    4
    5
    scala> for(i <- 0 until a.length) println(a(i))
    1
    2
    3
    4
    5
    【尖叫提示】
    0 until n——生成一系列的数字，包含0，不包含n，左闭右开
    0 to n ——包含0，也包含n
    
    //3.数组求和，要针对数值型，否则报错
    scala> val a = Array(1,2,3,4)
    a: Array[Int] = Array(1, 2, 3, 4)
    scala> a.sum
    res49: Int = 10
    
    //4.求数组最大值
    scala> val a = Array(4,1,2,4,10)
    a: Array[Int] = Array(4, 1, 2, 4, 10)
    scala> a.max
    res50: Int = 10
    //5.最小值
    scala> val a = Array(4,1,2,4,10)
    a: Array[Int] = Array(4, 1, 2, 4, 10)
    scala> a.min
    res51: Int = 1
    //6.排序
    scala> a.sorted
    res53: Array[Int] = Array(1, 2, 4, 4, 10)
    // 降序
    scala> a.sorted.reverse
    res56: Array[Int] = Array(10, 4, 4, 2, 1)

## 1.元组的使用详解 ##

**元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变的。**

***【1.语法格式】***

*  **val/var 元组 = (元素1, 元素2, 元素3....)   ** //使用括号来定义元组
 *  **val/var 元组 = 元素1-> 元素2   //使用‘’箭头’来定义元素（元组只有两个元素）**

// 可以直接使用括号来定义一个元组
    scala> val a = (1, "张三", 20, "北京市")
    a: (Int, String, Int, String) = (1,张三,20,北京市)
    //使用箭头,注意，这种元组只有两个元素
    scala> val a = 1->5
    a: (Int, Int) = (1,5)
    scala> val z = "x"-> "y"
    z: (String, String) = (x,y)

***【2.访问元组】***  
**使用\_1、\_2、\_3....来访问元组中的元素，\_1表示访问第一个元素，依次类推**

// 1.可以直接使用括号来定义一个元组
    scala> val a = (1, "张三", 20, "北京市")
    a: (Int, String, Int, String) = (1,张三,20,北京市)
    // 2.获取第一个元素
    scala> a._1
    res57: Int = 1
    // 3.获取第二个元素
    scala> a._2
    res58: String = 张三
    // 4.不能修改元组中的值
    scala> a._1 = 2
    <console>:13: error: reassignment to val
    a._1 = 2
    ^

## 2.列表的使用详解 ##

**    List是scala中最重要的、也是最常用的数据结构。在scala中，也有两种列表，一种是不可变列表、另一种是可变列表。List具备以下性质：**

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

### 2.1 不可变列表 ###

**不可变列表就是列表的元素、长度都是不可变的。**  
***【1.语法格式】***

1.  **val/var 变量名 = List(元素1, 元素2, 元素3...)**
2.  **val/var 变量名 = Nil   //使用 Nil 创建一个不可变的空列表**
3.  **val/var 变量名 = 元素1 :: 元素2 :: Nil   //使用 :: 方法创建一个不可变列表**

//方式1：使用 List(元素1, 元素2, 元素3, ...) 来创建一个不可变列表
    scala> val a = List(1,2,3,4,5)
    a: List[Int] = List(1,2,3,4,5)
    
    //方式2：使用Nil创建一个不可变的空列表
    scala> val a = Nil
    a: scala.collection.immutable.Nil.type = List()
    
    //方式3：使用 :: 方法创建列表，包含-2、-1,3三个元素
    scala> val a = -2 :: -1::3 :: Nil
    a: List[Int] = List(-2, -1, 3)

### 2.2 可变列表 ###

**可变列表就是列表的元素、长度都是可变的。要使用可变列表。**

**要使用可变列表，先要导入 import scala.collection.mutable.ListBuffer**  
***\[尖叫提示\]***

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

***【1.语法格式】***

1.  **val/var 变量名 = ListBuffer\[Int\]()**
2.  **val/var 变量名 = ListBuffer(元素1，元素2，元素3...)**

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

***【2.可变列表的操作】***

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

// 导入不可变列表
    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
    58
    // 追加一个元素
    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)

### 2.3 列表的常见操作（可变列表与不可变列表） ###

**2.3.1 判断列表是否为空（ isEmpty ）**

示例1：使用length方法来获取列表长度
    scala> val a = List(1,2,3,4)
    a: List[Int] = List(1, 2, 3, 4)
    60
    scala> a.length
    res0: Int = 4
    scala> a.isEmpty
    res16: Boolean = false
    使用isEmpty代替 length == 0，效率更高

**2.3.2拼接两个列表（ ++ ）**

示例2：使用++方法来拼接连接列表来形成一个新的列表
    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> val c = a ++ b
    c: List[Int] = List(1, 2, 3, 4, 5, 6)

**2.3.3获取列表的首个元素（ head ）和剩余部分( tail )**

示例3：获取列表的首个元素和剩余部分
    1. 使用head方法，获取列表的首个元素
    2. 使用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)

**2.3.1反转列表（ reverse ）**

示例4：使用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)

**2.3.1获取前缀（ take ）、获取后缀（ drop ）**

示例5：获取列表的前缀、后缀以及使用take方法获取前n个元素
    scala> val a = List(1,2,3,4,5)
    a: List[Int] = List(1, 2, 3, 4, 5)
    // 获取列表a的前3个元素
    scala> a.take(3)
    res10: List[Int] = List(1, 2, 3)
    使用drop方法获取除了前3个元素以外的元素
    scala> val a = List(1,2,3,4, 5)
    a: List[Int] = List(1, 2, 3, 4, 5)
    // 获取除了前3个元素以外的元素
    scala> a.drop(3)
    res11: List[Int] = List(4, 5)

**2.3.1扁平化（ flaten ），因为列表数组之类的都可以嵌套的。**

示例6：扁平化操作，扁平化表示将列表中的列表中的所有元素放到一个列表中。使用flatten方法来进行扁平化
    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))
    62
    scala> a.flatten
    res15: List[Int] = List(1, 2, 3, 4, 5)

**2.3.1拉链（ zip ）和拉开（ unzip ）**

示例7：拉链与拉开
    使用zip将两个列表，组合成一个元素为元组的列表
    scala> val a = List("张三", "李四", "王五")
    a: List[String] = List(张三, 李四, 王五)
    scala> val b = List(19, 20, 21)
    b: List[Int] = List(19, 20, 21)
    scala> a.zip(b)
    res16: List[(String, Int)] = List((张三,19), (李四,20), (王五,21))
    使用unzip将一个包含元组的列表，解开成两个列表的元组
    scala> res16.unzip
    res17: (List[String], List[Int]) = (List(张三, 李四, 王五),List(19, 20, 21)
    转换字符串

**2.3.1转换字符串（ toString ）**

示例8：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)

**2.3.1生成字符串（ mkString ）**

示例9：mkString表示使用什么样的分隔符来展示列表
    scala> a.mkString(",")
    res20: String = 1,2,3,4
    // 可以调用mkString的另一种重载方式，加上前缀和后缀
    scala> a.mkString("[", ":", "]")
    res22: String = [1:2:3:4]

**2.3.1并集（ union ）**

union表示对两个列表取并集，不去重
    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)

**2.3.1交集（ intersect ）**

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)

**2.3.1差集（ diff ）**

diff表示对两个列表取差集，例如： a1.diff(a2)，表示将a1中不包含a2中的元素
    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)

## 3.Set的使用 ##

Set(集)是代表没有重复元素的集合。在Scala中集set也分可变和不可变两种。Set具备以下性质：

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

### 3.1 不可变集set ###

**【1.语法格式】**

1.  **val/var 变量名 = Set\[类型\]()**
2.  **val/var 变量名 = Set\[类型\](元素1, 元素2, 元素3...)**

**【2.set的操作】**

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

// 创建集
    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)

### 3.2 可变集set ###

**要使用可变集，必须要手动导入： import scala.collection.mutable.Set**

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)

## 4.Map映射的使用 ##

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

### **4.1 不可变Map** ###

**【语法结构】**

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

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

### 4.2可变Map ###

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

scala> import scala.collection.mutable.Map
    import scala.collection.mutable.Map
    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

### 4.3 Map的操作（可变Map与不可变Map） ###

1.  Map基本操作
2.  获取值( map(key) )
3.  获取所有key（ map.keys ）
4.  获取所有value（ map.values ）
5.  遍历map集合
6.  getOrElse
7.  增加key,value对
8.  删除key

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, wangw
    u -> 35)
    // 将lisi从可变映射中移除
    scala> map - "lisi"
    res23: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)