Scala集合详解(第七章:集合、数组、列表、set集合、map集合、元组、队列、并行)(尚硅谷笔记)

旧城等待， 2024-03-26 12:48 38阅读 0赞

#### 集合 ####

*  第七章:集合
 *   *  7.1 集合简介
     *   *  7.1.1 不可变集合继承图
         *  7.1.2 可变集合继承图
     *  7.2 数组
     *   *  7.2.1 不可变数组
         *  7.2.2 可变数组
         *  7.2.3 不可变数组与可变数组的转换
         *  7.2.4 多维数组
     *  7.3 列表 List
     *   *  7.3.1 不可变 List
         *  7.3.2 可变 ListBuffer
     *  7.4 Set 集合
     *   *  7.4.1 不可变 Set
         *  7.4.2 可变 mutable.Set
     *  7.5 Map 集合
     *   *  7.5.1 不可变 Map
         *  7.5.2 可变 Map
     *  7.6 元组
     *  7.7 集合常用函数
     *   *  7.7.1 基本属性和常用操作
         *  7.7.2 衍生集合
         *  7.7.3 集合计算简单函数
         *  7.7.4 集合计算高级函数
         *  7.7.5 普通 WordCount 案例
         *  7.7.6 复杂 WordCount 案例
     *  7.8 队列
     *  7.9 并行集合

--------------------

## 第七章:集合 ##

### 7.1 集合简介 ###

**1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable  
特质。**  
**2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两  
个包**

*  不可变集合：scala.collection.immutable
 *  可变集合： scala.collection.mutable

**3）Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而  
不会对原对象进行修改。类似于 java 中的 String 对象**  
**4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似  
于 java 中 StringBuilder 对象**  
`建议：在操作集合的时候，不可变用符号，可变用方法`

#### 7.1.1 不可变集合继承图 ####

![在这里插入图片描述][9a93aa1353c84e86b4a9f31ec8fdb7c4.png]  
**1）Set、Map 是 Java 中也有的集合**  
**2）Seq 是 Java 没有的，我们发现 List 归属到 Seq 了，因此这里的 List 就和 Java 不是同一个  
概念了**  
**3）我们前面的 for 循环有一个 1 to 3，就是 IndexedSeq 下的 Range**  
**4）String 也是属于 IndexedSeq**  
**5）我们发现经典的数据结构比如 Queue 和 Stack 被归属到 LinearSeq(线性序列)**  
**6）大家注意 Scala 中的 Map 体系有一个 SortedMap，说明 Scala 的 Map 可以支持排序**  
**7）IndexedSeq 和 LinearSeq 的区别：**

*  （1）IndexedSeq 是通过索引来查找和定位，因此速度快，比如 String 就是一个索引集合，通过索引即可定位
 *  （2）LinearSeq 是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找

#### 7.1.2 可变集合继承图 ####

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

### 7.2 数组 ###

#### 7.2.1 不可变数组 ####

**加粗样式**1）第一种方式定义数组

> 定义：val arr1 = new ArrayInt

*  （1）new 是关键字
 *  （2）\[Int\]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定 Any
 *  （3）(10)，表示数组的大小，确定后就不可以变化

**2）案例实操**

object TestArray{
        
     def main(args: Array[String]): Unit = {
        
     //（1）数组定义
     val arr01 = new Array[Int](4)
     println(arr01.length) // 4
     //（2）数组赋值
     //（2.1）修改某个元素的值
     arr01(3) = 10
     //（2.2）采用方法的形式给数组赋值
     arr01.update(0,1)
     //（3）遍历数组
     //（3.1）查看数组
     println(arr01.mkString(","))
     //（3.2）普通遍历
     for (i <- arr01) {
        
     println(i)
     }
     //（3.3）简化遍历
     def printx(elem:Int): Unit = {
        
     println(elem)
     }
     arr01.foreach(printx)
     // arr01.foreach((x)=>{println(x)})
     // arr01.foreach(println(_))
     arr01.foreach(println)
     //（4）增加元素（由于创建的是不可变数组，增加元素，其实是产生新的数
    组）
     println(arr01)
     val ints: Array[Int] = arr01 :+ 5
     println(ints)
     }
    }

**3）第二种方式定义数组**  
val arr1 = Array(1, 2)

*  （1）在定义数组时，直接赋初始值
 *  （2）使用 apply 方法创建数组对象

**4）案例实操**

object TestArray{
        
     def main(args: Array[String]): Unit = {
        
     var arr02 = Array(1, 3, "bobo")
     println(arr02.length)
     for (i <- arr02) {
        
     println(i)
     }
     }
    }

#### 7.2.2 可变数组 ####

**1）定义变长数组**

> val arr01 = ArrayBuffer\[Any\](3, 2, 5)

*  （1）\[Any\]存放任意数据类型
 *  （2）(3, 2, 5)初始化好的三个元素
 *  （3）ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer

**2）案例实操**

*  （1）ArrayBuffer 是有序的集合
 *  （2）增加元素使用的是 append 方法()，支持可变参数

import scala.collection.mutable.ArrayBuffer
    object TestArrayBuffer {
        
     def main(args: Array[String]): Unit = {
        
     //（1）创建并初始赋值可变数组
     val arr01 = ArrayBuffer[Any](1, 2, 3)
     //（2）遍历数组
     for (i <- arr01) {
        
     println(i)
     }
     println(arr01.length) // 3
     println("arr01.hash=" + arr01.hashCode())
     //（3）增加元素
     //（3.1）追加数据
     arr01.+=(4)
     //（3.2）向数组最后追加数据
     arr01.append(5,6)
     //（3.3）向指定的位置插入数据
     arr01.insert(0,7,8)
     println("arr01.hash=" + arr01.hashCode())
     //（4）修改元素
     arr01(1) = 9 //修改第 2 个元素的值
     println("--------------------------")
     for (i <- arr01) {
        
     println(i)
     }
     println(arr01.length) // 5
     }
    }

#### 7.2.3 不可变数组与可变数组的转换 ####

**1）说明**

> arr1.toBuffer //不可变数组转可变数组  
> arr2.toArray //可变数组转不可变数组

*  （1）arr2.toArray 返回结果才是一个不可变数组，arr2 本身没有变化
 *  （2）arr1.toBuffer 返回结果才是一个可变数组，arr1 本身没有变化

**2）案例实操**

object TestArrayBuffer {
        
     def main(args: Array[String]): Unit = {
        
     //（1）创建一个空的可变数组
     val arr2 = ArrayBuffer[Int]()
     //（2）追加值
     arr2.append(1, 2, 3)
     println(arr2) // 1,2,3
     //（3）ArrayBuffer ==> Array
     //（3.1）arr2.toArray 返回的结果是一个新的定长数组集合
     //（3.2）arr2 它没有变化
     val newArr = arr2.toArray
     println(newArr)
     
     //（4）Array ===> ArrayBuffer
     //（4.1）newArr.toBuffer 返回一个变长数组 newArr2
     //（4.2）newArr 没有任何变化，依然是定长数组
     val newArr2 = newArr.toBuffer
     newArr2.append(123)
     println(newArr2)
     }
     }

#### 7.2.4 多维数组 ####

**1）多维数组定义**

> val arr = Array.ofDimDouble  
> 说明：二维数组中有三个一维数组，每个一维数组中有四个元素

**2）案例实操**

object DimArray {
        
     def main(args: Array[String]): Unit = {
        
     
     //（1）创建了一个二维数组, 有三个元素，每个元素是，含有 4 个元素一维
    数组()
     val arr = Array.ofDim[Int](3, 4)
     arr(1)(2) = 88
     //（2）遍历二维数组
     for (i <- arr) {
         //i 就是一维数组
     for (j <- i) {
        
     print(j + " ")
     }
     println()
     }
     }
    }

### 7.3 列表 List ###

#### 7.3.1 不可变 List ####

**1）说明**

*  （1）List 默认为不可变集合
 *  （2）创建一个 List（数据有顺序，可重复）
 *  （3）遍历 List
 *  （4）List 增加数据
 *  （5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
 *  （6）取指定数据
 *  （7）空集合 Nil  
    **2）案例实操**

object TestList {
        
     def main(args: Array[String]): Unit = {
        
     //（1）List 默认为不可变集合
     //（2）创建一个 List（数据有顺序，可重复）
     val list: List[Int] = List(1,2,3,4,3)
     
     //（7）空集合 Nil
     val list5 = 1::2::3::4::Nil
     //（4）List 增加数据
     //（4.1）::的运算规则从右向左
     //val list1 = 5::list
     val list1 = 7::6::5::list
     //（4.2）添加到第一个元素位置
     val list2 = list.+:(5)
     //（5）集合间合并：将一个整体拆成一个一个的个体，称为扁平化
     val list3 = List(8,9)
     //val list4 = list3::list1
     val list4 = list3:::list1
     //（6）取指定数据
     println(list(0))
     //（3）遍历 List
     //list.foreach(println)
     //list1.foreach(println)
     //list3.foreach(println)
     //list4.foreach(println)
     list5.foreach(println)
     }
    }

#### 7.3.2 可变 ListBuffer ####

**1）说明**

*  （1）创建一个可变集合 ListBuffer
 *  （2）向集合中添加数据
 *  （3）打印集合数据

**2）案例实操**

import scala.collection.mutable.ListBuffer
    object TestList {
        
     def main(args: Array[String]): Unit = {
        
     //（1）创建一个可变集合
     val buffer = ListBuffer(1,2,3,4)
     //（2）向集合中添加数据
     buffer.+=(5)
    buffer.append(6)
    buffer.insert(1,2)
     //（3）打印集合数据
     buffer.foreach(println)
    //（4）修改数据
    buffer(1) = 6
    buffer.update(1,7)
    //（5）删除数据
    buffer.-(5)
    buffer.-=(5)
    buffer.remove(5)
     }
    }

### 7.4 Set 集合 ###

> 默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用  
> scala.collection.mutable.Set 包

#### 7.4.1 不可变 Set ####

**1）说明**

*  （1）Set 默认是不可变集合，数据无序
 *  （2）数据不可重复
 *  （3）遍历集合

**2）案例实操**

object TestSet {
        
     def main(args: Array[String]): Unit = {
        
     //（1）Set 默认是不可变集合，数据无序
     val set = Set(1,2,3,4,5,6)
     //（2）数据不可重复
     val set1 = Set(1,2,3,4,5,6,3)
     //（3）遍历集合
     for(x<-set1){
        
     println(x)
     }
     }
    }

#### 7.4.2 可变 mutable.Set ####

**1）说明**

*  （1）创建可变集合 mutable.Set
 *  （2）打印集合
 *  （3）集合添加元素
 *  （4）向集合中添加元素，返回一个新的 Set
 *  （5）删除数据

**2）案例实操**

object TestSet {
        
     def main(args: Array[String]): Unit = {
        
     //（1）创建可变集合
     val set = mutable.Set(1,2,3,4,5,6)
     //（3）集合添加元素
     set += 8
     //（4）向集合中添加元素，返回一个新的 Set
     val ints = set.+(9)
     println(ints)
     println("set2=" + set)
     //（5）删除数据
     set-=(5)
      //（2）打印集合
     set.foreach(println)
     println(set.mkString(","))
     }
    }

### 7.5 Map 集合 ###

> Scala 中的 Map 和 Java 类似，也是一个散列表，它存储的内容也是键值对（key-value）  
> 映射

#### 7.5.1 不可变 Map ####

**1）说明**

*  （1）创建不可变集合 Map
 *  （2）循环打印
 *  （3）访问数据
 *  （4）如果 key 不存在，返回 0

**2）案例实操**

object TestMap {
        
     def main(args: Array[String]): Unit = {
        
     // Map
     //（1）创建不可变集合 Map
     val map = Map( "a"->1, "b"->2, "c"->3 )
     //（3）访问数据
     for (elem <- map.keys) {
        
     // 使用 get 访问 map 集合的数据，会返回特殊类型 Option(选项):
    有值（Some），无值(None)
     println(elem + "=" + map.get(elem).get)
     }
     //（4）如果 key 不存在，返回 0
     println(map.get("d").getOrElse(0))
     println(map.getOrElse("d", 0))
     //（2）循环打印
     map.foreach((kv)=>{
        println(kv)})
     }
    }

#### 7.5.2 可变 Map ####

**1）说明**

*  （1）创建可变集合
 *  （2）打印集合
 *  （3）向集合增加数据
 *  （4）删除数据
 *  （5）修改数据

**2）案例实操**

object TestSet {
        
     def main(args: Array[String]): Unit = {
        
     //（1）创建可变集合
     val map = mutable.Map( "a"->1, "b"->2, "c"->3 )
     //（3）向集合增加数据
     map.+=("d"->4)
     // 将数值 4 添加到集合，并把集合中原值 1 返回
     val maybeInt: Option[Int] = map.put("a", 4)
     println(maybeInt.getOrElse(0))
     //（4）删除数据
     map.-=("b", "c")
     //（5）修改数据
     map.update("d",5)
    map("d") = 5
     //（2）打印集合
     map.foreach((kv)=>{
        println(kv)})
     }
    }

### 7.6 元组 ###

**1）说明**

> 元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。  
> `注意：元组中最大只能有 22 个元素。`

**2）案例实操**

*  （1）声明元组的方式：(元素 1，元素 2，元素 3)
 *  （2）访问元组
 *  （3）Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为对偶

object TestTuple {
        
     def main(args: Array[String]): Unit = {
        
     //（1）声明元组的方式：(元素 1，元素 2，元素 3)
     val tuple: (Int, String, Boolean) = (40,"bobo",true)
     //（2）访问元组
     //（2.1）通过元素的顺序进行访问，调用方式：_顺序号
     println(tuple._1)
     println(tuple._2)
     println(tuple._3)
     //（2.2）通过索引访问数据
     println(tuple.productElement(0))
     //（2.3）通过迭代器访问数据
     for (elem <- tuple.productIterator) {
        
     println(elem)
     }
     //（3）Map 中的键值对其实就是元组,只不过元组的元素个数为 2，称之为
    对偶
     val map = Map("a"->1, "b"->2, "c"->3)
     val map1 = Map(("a",1), ("b",2), ("c",3))
     map.foreach(tuple=>{
        println(tuple._1 + "=" + tuple._2)})
     }
    }

### 7.7 集合常用函数 ###

#### 7.7.1 基本属性和常用操作 ####

**1）说明**

*  （1）获取集合长度
 *  （2）获取集合大小
 *  （3）循环遍历
 *  （4）迭代器
 *  （5）生成字符串
 *  （6）是否包含

**2）案例实操**

object TestList {
        
     def main(args: Array[String]): Unit = {
        
     val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
     //（1）获取集合长度
     println(list.length)
     //（2）获取集合大小,等同于 length
     println(list.size)
     //（3）循环遍历
     list.foreach(println)
     //（4）迭代器
     for (elem <- list.itera tor) {
        
     println(elem)
     }
     //（5）生成字符串
     println(list.mkString(","))
     //（6）是否包含
     println(list.contains(3))
     }
    }

#### 7.7.2 衍生集合 ####

**1）说明**

*  （1）获取集合的头
 *  （2）获取集合的尾（不是头的就是尾）
 *  （3）集合最后一个数据
 *  （4）集合初始数据（不包含最后一个）
 *  （5）反转
 *  （6）取前（后）n 个元素
 *  （7）去掉前（后）n 个元素
 *  （8）并集
 *  （9）交集
 *  （10）差集
 *  （11）拉链
 *  （12）滑窗  
    **2）案例实操**

object TestList {
        
     def main(args: Array[String]): Unit = {
        
     val list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7)
     val list2: List[Int] = List(4, 5, 6, 7, 8, 9, 10)
     //（1）获取集合的头
     println(list1.head)
     //（2）获取集合的尾（不是头的就是尾）
     println(list1.tail)
     //（3）集合最后一个数据
     println(list1.last)
     //（4）集合初始数据（不包含最后一个）
     println(list1.init)
     //（5）反转
     println(list1.reverse)
     //（6）取前（后）n 个元素
      println(list1.take(3))
     println(list1.takeRight(3))
     //（7）去掉前（后）n 个元素
     println(list1.drop(3))
     println(list1.dropRight(3))
     //（8）并集
     println(list1.union(list2))
     //（9）交集
     println(list1.intersect(list2))
     //（10）差集
     println(list1.diff(list2))
     //（11）拉链 注:如果两个集合的元素个数不相等，那么会将同等数量的数据进
    行拉链，多余的数据省略不用
     println(list1.zip(list2))
     //（12）滑窗
     list1.sliding(2, 5).foreach(println)
     }
    }

#### 7.7.3 集合计算简单函数 ####

**1）说明**

*  （1）求和
 *  （2）求乘积
 *  （3）最大值
 *  （4）最小值
 *  （5）排序

**2）实操**

object TestList {
        
     def main(args: Array[String]): Unit = {
        
     val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
     //（1）求和
     println(list.sum)
      //（2）求乘积
     println(list.product)
     //（3）最大值
     println(list.max)
     //（4）最小值
     println(list.min)
     //（5）排序
     // （5.1）按照元素大小排序
     println(list.sortBy(x => x))
     // （5.2）按照元素的绝对值大小排序
     println(list.sortBy(x => x.abs))
     // （5.3）按元素大小升序排序
    println(list.sortWith((x, y) => x < y))
    // （5.4）按元素大小降序排序
     println(list.sortWith((x, y) => x > y))
     }
    }

*  （1）sorted 对一个集合进行自然排序，通过传递隐式的 Ordering
 *  （2）sortBy 对一个属性或多个属性进行排序，通过它的类型。
 *  （3）sortWith 基于函数的排序，通过一个 comparator 函数，实现自定义排序的逻辑。

#### 7.7.4 集合计算高级函数 ####

**1）说明**

*  （1）过滤 遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
 *  （2）转化/映射（map）将集合中的每一个元素映射到某一个函数
 *  （3）扁平化
 *  （4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten 操作  
    集合中的每个元素的子元素映射到某个函数并返回新集合
 *  （5）分组(group) 按照指定的规则对集合的元素进行分组
 *  （6）简化（归约）
 *  （7）折叠

**2）实操**

object TestList {
        
     def main(args: Array[String]): Unit = {
        
     val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
     val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 
    5, 6), List(7, 8, 9))
     val wordList: List[String] = List("hello world", "hello 
    atguigu", "hello scala")
     //（1）过滤
     println(list.filter(x => x % 2 == 0))
     //（2）转化/映射
     println(list.map(x => x + 1))
     //（3）扁平化
     println(nestedList.flatten)
     //（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten
    操作
     println(wordList.flatMap(x => x.split(" ")))
     //（5）分组
     println(list.groupBy(x => x % 2))
     }
    }

**3）Reduce 方法**

> Reduce 简化（归约） ：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最  
> 终获取结果。案例实操

object TestReduce {
        
     def main(args: Array[String]): Unit = {
        
     val list = List(1,2,3,4)
     // 将数据两两结合，实现运算规则
     val i: Int = list.reduce( (x,y) => x-y )
     println("i = " + i)
     // 从源码的角度，reduce 底层调用的其实就是 reduceLeft
     //val i1 = list.reduceLeft((x,y) => x-y)
     // ((4-3)-2-1) = -2
     val i2 = list.reduceRight((x,y) => x-y)
     println(i2)
     }
    }

**4）Fold 方法**

> Fold 折叠：化简的一种特殊情况。

*  （1）案例实操：fold 基本使用

object TestFold {
        
     def main(args: Array[String]): Unit = {
        
     val list = List(1,2,3,4)
     // fold 方法使用了函数柯里化，存在两个参数列表
     // 第一个参数列表为 ： 零值（初始值）
     // 第二个参数列表为： 简化规则
     // fold 底层其实为 foldLeft
     val i = list.foldLeft(1)((x,y)=>x-y)
     val i1 = list.foldRight(10)((x,y)=>x-y)
     println(i)
     println(i1)
     }
    }

*  （2）案例实操：两个集合合并

object TestFold {
        
     def main(args: Array[String]): Unit = {
        
     // 两个 Map 的数据合并
     val map1 = mutable.Map("a"->1, "b"->2, "c"->3)
     val map2 = mutable.Map("a"->4, "b"->5, "d"->6)
     val map3: mutable.Map[String, Int] = map2.foldLeft(map1) 
    {
        
     (map, kv) => {
        
     val k = kv._1
     val v = kv._2
     map(k) = map.getOrElse(k, 0) + v
     map
     }
     }
     println(map3)
     }
    }

#### 7.7.5 普通 WordCount 案例 ####

**1）需求**

> 单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果

**2）需求分析**  
![在这里插入图片描述][893e0dd5a7a949c79ba42bd8f0b875c5.png]  
**3）案例实操**

object TestWordCount {
        
     def main(args: Array[String]): Unit = {
        
      // 单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结
    果
     val stringList = List("Hello Scala Hbase kafka", "Hello 
    Scala Hbase", "Hello Scala", "Hello")
     // 1) 将每一个字符串转换成一个一个单词
     val wordList: List[String] = 
    stringList.flatMap(str=>str.split(" "))
     //println(wordList)
     // 2) 将相同的单词放置在一起
     val wordToWordsMap: Map[String, List[String]] = 
    wordList.groupBy(word=>word)
     //println(wordToWordsMap)
     // 3) 对相同的单词进行计数
     // (word, list) => (word, count)
     val wordToCountMap: Map[String, Int] = 
    wordToWordsMap.map(tuple=>(tuple._1, tuple._2.size))
     // 4) 对计数完成后的结果进行排序（降序）
     val sortList: List[(String, Int)] = 
    wordToCountMap.toList.sortWith {
        
     (left, right) => {
        
     left._2 > right._2
     }
     }
     // 5) 对排序后的结果取前 3 名
     val resultList: List[(String, Int)] = sortList.take(3)
     println(resultList)
     }
    }

#### 7.7.6 复杂 WordCount 案例 ####

**1）方式一**

object TestWordCount {
        
     def main(args: Array[String]): Unit = {
        
     // 第一种方式（不通用）
     val tupleList = List(("Hello Scala Spark World ", 4), ("Hello 
    Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))
     val stringList: List[String] = tupleList.map(t=>(t._1 + " 
    ") * t._2)
     //val words: List[String] = 
    stringList.flatMap(s=>s.split(" "))
     val words: List[String] = stringList.flatMap(_.split(" "))
     //在 map 中，如果传进来什么就返回什么，不要用_省略
     val groupMap: Map[String, List[String]] = 
    words.groupBy(word=>word)
     //val groupMap: Map[String, List[String]] = 
    words.groupBy(_)
     // (word, list) => (word, count)
     val wordToCount: Map[String, Int] = groupMap.map(t=>(t._1, 
    t._2.size))
     val wordCountList: List[(String, Int)] = 
    wordToCount.toList.sortWith {
        
     (left, right) => {
        
     left._2 > right._2
     }
     }.take(3)
     //tupleList.map(t=>(t._1 + " ") * t._2).flatMap(_.split(" 
    ")).groupBy(word=>word).map(t=>(t._1, t._2.size))
     println(wordCountList)
     }
    }

**2）方式二**

object TestWordCount {
        
     def main(args: Array[String]): Unit = {
        
     val tuples = List(("Hello Scala Spark World", 4), ("Hello 
    Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1))
     // (Hello,4),(Scala,4),(Spark,4),(World,4)
     // (Hello,3),(Scala,3),(Spark,3)
     // (Hello,2),(Scala,2)
     // (Hello,1)
     val wordToCountList: List[(String, Int)] = tuples.flatMap 
    {
        
     t => {
        
     val strings: Array[String] = t._1.split(" ")
     strings.map(word => (word, t._2))
     }
     }
     // Hello, List((Hello,4), (Hello,3), (Hello,2), (Hello,1))
     // Scala, List((Scala,4), (Scala,3), (Scala,2)
     // Spark, List((Spark,4), (Spark,3)
     // Word, List((Word,4))
     val wordToTupleMap: Map[String, List[(String, Int)]] = 
    wordToCountList.groupBy(t=>t._1)
     val stringToInts: Map[String, List[Int]] = 
    wordToTupleMap.mapValues {
        
     datas => datas.map(t => t._2)
     }
     stringToInts
     /*
     val wordToCountMap: Map[String, List[Int]] = 
    wordToTupleMap.map {
     t => {
     (t._1, t._2.map(t1 => t1._2))
     }
     }
     val wordToTotalCountMap: Map[String, Int] = 
    wordToCountMap.map(t=>(t._1, t._2.sum))
     println(wordToTotalCountMap)
     */
     }
    }

### 7.8 队列 ###

**1）说明**

> Scala 也提供了队列（Queue）的数据结构，队列的特点就是先进先出。进队和出队的方  
> 法分别为 enqueue 和 dequeue。

**2）案例实操**

object TestQueue {
        
     def main(args: Array[String]): Unit = {
        
     val que = new mutable.Queue[String]()
     que.enqueue("a", "b", "c")
     println(que.dequeue())
     println(que.dequeue())
     println(que.dequeue())
     }
    }

### 7.9 并行集合 ###

**1）说明**

> Scala 为了充分使用多核 CPU，提供了并行集合（有别于前面的串行集合），用于多核  
> 环境的并行计算。

**2）案例实操**

object TestPar {
        
     def main(args: Array[String]): Unit = {
        
      val result1 = (0 to 100).map{
        case _ => 
    Thread.currentThread.getName}
     val result2 = (0 to 100).par.map{
        case _ => 
    Thread.currentThread.getName}
     println(result1)
     println(result2)
     }
    }

[9a93aa1353c84e86b4a9f31ec8fdb7c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/7674be20a7ce4c88bcef70db8347a873.png
[186653a25b1844d9995f186070435d73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/935feba2f05e415f8b735f1298a97cac.png
[893e0dd5a7a949c79ba42bd8f0b875c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/bb9f3cec0f4d445f921f76236ef3dc6b.png