五、Scala中的集合

1.集合简介

1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有的集合都扩展自 Iterable
特质。
2）对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两
个包
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable
3）Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而
不会对原对象进行修改。类似于 java 中的 String 对象
4）可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似
于 java 中 StringBuilder 对象

2.数组

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

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

2.3 不可变数组与可变数组的转换

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

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

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

3.列表List

3.1不可变List

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

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

3.2 可变ListBuffer

1）说明
（1）创建一个可变集合 ListBuffer
（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)
 }
}

4.Set集合

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

4.1 不可变Set

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

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

4.2 可变mutable.Set

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(","))
 }
}

5. Map集合

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

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

6.元组

元组可以理解为一个容器，可以存放各种相同或不同类型的数据。
元组中最大只能有22个元素。

7. 集合常用函数

7.1 基本属性和常用操作

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

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.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))
 }
}
 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.3 集合计算简单函数

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

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.4 集合计算高级函数

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

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