集合学习内容总结

集合简介

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.ArrayBufferobject 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    //可变数组转不可变数组

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

 

列表（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）空集合 Nilval 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 等。