集合简介
1、Scala 的集合有三大类：序列 Seq、集Set、映射 Map，所有的集合都扩展自 Iterable
特质。
2、对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两个包
不可变集合：scala.collection.immutable
可变集合： scala.collection.mutable
3、Scala 不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象， 而不会对原对象进行修改。类似于 java 中的 String
4、对象可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似于 java 中 StringBuilder 对象
数组
不可变数组
1、第一种方式定义数组
定义：val arr1 = new Array[Int](10)
（1）new 是关键字
（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any
（3）(10)，表示数组的大小，确定后就不可以变化
object FixedArrayDemo {
def main(args: Array[String]): Unit = {
// 严格遵循要求的定义
val arr1 = new Array[Int](10) // (1) new关键字 (2) [Int]类型 (3) 固定长度10
// 类型验证演示
val anyArr = new Array[Any](3) // 可存任意类型的版本
// 初始值验证（Int数组初始化为0）
println("初始数组值：")
println(arr1.mkString(", ")) // 输出：0, 0, 0, 0, 0, 0, 0, 0, 0, 0
// 合法操作演示
arr1(0) = 100 // 修改第一个元素
arr1(arr1.length-1) = 999 // 修改最后一个元素（索引9）
// 类型安全验证（这行如果取消注释会编译报错）
// arr1(1) = "hello" // 类型不匹配，因为声明的是Int数组
// 长度不可变验证（这行如果取消注释会运行时报错）
// arr1(10) = 1000 // 索引越界（有效索引0-9）
// 最终结果输出
println("\n修改后的数组值：")
println(arr1.mkString(", ")) // 输出：100, 0, ..., 999
}
}2、第二种方式定义数组
val arr1 = Array(1, 2)
（1）在定义数组时，直接赋初始值
（2）使用apply 方法创建数组对象
object TestArray{
def main(args: Array[String]): Unit = {
var arr02 = Array(1, 3, "bobo")
println(arr02.length)
for (i <- arr02) {
println(i)
}
}
}
可变数组
定义变长数组
val arr01 = ArrayBuffer[Any](3, 2, 5)
（1）[Any]存放任意数据类型
（2）(3, 2, 5)初始化好的三个元素
（3）ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
object VariableArrayDemo {
def main(args: Array[String]): Unit = {
// 严格按要求定义可变数组
val arr01 = ArrayBuffer[Any](3, 2, 5) // (1) [Any]类型 (2) 初始化3个元素 (3) 需要显式导入
// 打印初始状态
println("初始数组:")
println(s"长度: ${arr01.length}, 内容: ${arr01.mkString(", ")}") // 长度: 3, 内容: 3, 2, 5
// 演示添加混合类型元素（利用Any特性）
arr01 += "hello" // 添加String类型
arr01 += true // 添加Boolean类型
arr01 += Array(7.5, 8.5) // 添加嵌套数组
// 动态修改演示
arr01(0) = "替换后的值" // 修改第一个元素为字符串
arr01 -= 2 // 删除元素2（值删除而非索引）
// 打印修改后状态
println("\n修改后的数组:")
println(s"长度: ${arr01.length}, 内容: ${arr01.mkString(", ")}")
// 长度: 6, 内容: 替换后的值, 5, hello, true, [D@哈希值
// 典型操作验证（注释部分为错误示例）
// arr01(10) = 100 // 索引越界（当前最大索引5）
// arr01 += 1.23 // 合法操作（Double属于Any）
// arr01 += List(1,2,3) // 合法操作（List属于Any）
}
}不可变数组与可变数组的转换
arr1.toBuffer //不可变数组转可变数组
arr2.toArray //可变数组转不可变数组
- arr2.toArray 返回结果才是一个不可变数组，arr2 本身没有变化
- 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)
}
}
列表（List）
列表是 Scala 中最常用的集合类型之一，默认为不可变集合。
不可变 List：使用 List 类创建，一旦创建就不能修改。
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)
}
}
可变 ListBuffer：使用 ListBuffer 类创建，可以动态修改。
Set 集合
Set 集合是无序且不包含重复元素的集合。
不可变 Set：使用 Set 类创建。
可变 Set：使用 mutable.Set 类创建。
Map 集合
Map 集合是键值对（key-value）的集合，类似于 Java 中的 HashMap。
不可变 Map：使用 Map 类创建。
可变 Map：使用 mutable.Map 类创建。
元组（Tuple）
元组是一个可以包含多个不同类型元素的容器，最大可以有 22 个元素。
声明元组：使用小括号和逗号分隔元素，如 (1, "a", true)。
访问元组：通过下划线 _ 和元素的索引来访问，如 tuple._1。
集合常用函数
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))
}
}
Scala 集合提供了丰富的操作函数，包括遍历、过滤、映射、排序等。
基本属性和常用操作：如 length、size、foreach、mkString、contains 等。
衍生集合：如 head、tail、last、init、reverse、take、drop 等。
集合计算简单函数：如 sum、product、max、min、sortBy、sortWith 等。
集合计算高级函数：如 filter、map、flatten、flatMap、groupBy、reduce、fold 等。
![[蓝桥杯] 求和](https://i-blog.csdnimg.cn/direct/f1ce0cd7ae424ae88240815b1441c9b9.png)
