可变数组
定义变长数组
val arr01 = ArrayBuffer[Any](3, 2, 5)
（1）[Any]存放任意数据类型
（2）(3, 2, 5)初始化好的三个元素
（3）ArrayBuffer 需要引入 scala.collection.mutable.ArrayBuffer
案例实操
- ArrayBuffer 是有序的集合
- 增加元素使用的是 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
}
}
不可变数组与可变数组的转换
说明
arr1.toBuffer //不可变数组转可变数组
arr2.toArray //可变数组转不可变数组
- 不可变数组转可变数组：使用
to buffer函数，返回一个新的可变数组，原数组不变。 - 可变数组转不可变数组：使用
to array函数，返回一个新的不可变数组，原数组不变。
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)
}
}
多维数组
val arr = Array.ofDim[Double](3,4)
创建多维数组：使用 array of 函数，指定数据类型和规格（如三行四列）。
遍历多维数组：使用嵌套的 for 循环，逐行逐列遍历数组元素。
列表（List）
不可变列表：默认情况下，列表是不可变的，数据有序且可重复。
List 增加数据
集合间合并：将一个整体拆成一个一个的个体，称为扁平化
空集合 Nil
可变列表：使用 list buffer，需要导入相关包，支持添加、插入、修改和删除操作。
遍历列表：使用 for each 循环遍历列表元素。
实操案例
// 不可变list
object TestList {
def main(args: Array[String]): Unit = {
// (1) List默认为不可变集合
// (2) 创建一个List（数据有顺序，可重复）
val list: List[Int] = List(1,2,3,4,5)
// (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
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)
}
}
集合（Set）
默认情况下， Scala 使用的是不可变集合， 如果你想使用可变集合， 需要引用scala.collection.mutable.Set 包
不可变集合(Set)：数据无序且不可重复，使用 set 关键字创建，遍历时重复元素会被忽略。
可变集合( mutable.Set)：使用 mutable.set，支持打印集合、添加、删除操作，添加元素会返回新的集合。
// 不可变 Set
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)
}
}
// 可变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(","))
}
}Map(映射)集合
Scala 中的 Map 和 Java 类似，也是一个散列表，它存储的内容也是键值对（key-value） 映射
不可变Map：使用 map 关键字创建，存储键值对，数据无序，键(key)不可重复
访问数据：使用 get 方法，如果键不存在则返回默认值（如0）。
遍历映射：使用 for each 循环遍历键值对。
可变Map：使用 mutable map，支持打印集合、添加、删除、修改操作。
添加数据：使用 + 操作符添加键值对。
删除数据：使用 - 操作符删除指定键的键值对。
修改数据：直接通过键赋值修改。
// 不可变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.getOrElse("d", 0))
println(map.getOrElse("d", 0))
// (2) 循环打印
map.foreach((kv) => { println(kv) })
}
}
// 可变Map
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) })
}
}
注意事项
数据结构的选择：根据需求选择合适的数据结构，如有序且可重复的列表，无序且不可重复的集合。
操作的正确性：确保操作的变量类型正确，特别是在涉及可变和不可变数据结构时。
元组
元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据。说的简单点，就是将多个无关的数据封装为一个整体，称为元组。
注意：
元组可容纳各种类型的数据，最大只能有 22 个元素。
声明方式为元素间用逗号分隔。
可通过点杠或索引访问元素，也能用迭代器访问。
案例实操
声明元组的方式：(元素 1，元素 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)})
}
}集合常用函数
基本属性和常见操作
包括获取集合长度（size）和大小（size）。
循环遍历用 for each，迭代器用 for 循环，生成字符串用点 mkString。
判断是否包含特定值。
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.iterator) { println(elem) }
// (5) 生成字符串
println(list.mkString(","))
//（6）是否包含
println(list.contains(3))
}
}
衍生集合
获取列表的头、尾、最后一个数据，初始值为零，集合初始数据（不包含最后一个）
可进行反转、取前几个或后几个数据（take、take right），删除前几个或后几个元素（drop、drop right），求并集（union）、交集（intersect）、差集（diff）、拉链（zip）、滑窗（sliding）操作
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)
}
}集合计算简单函数
涉及求和、求乘积、求最大值、最小值和排序。
排序有按元素大小（sort）、按绝对值、升序（ascending）、降序（descending）等方式。
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 函数，实现自定义排序的逻辑。