Scala集合

最新推荐文章于 2024-06-15 01:14:41 发布

春山2

最新推荐文章于 2024-06-15 01:14:41 发布

阅读量850

点赞数 1

文章标签： scala 开发语言后端

本文链接：https://blog.csdn.net/qq_45041581/article/details/125126192

版权

1.Scala有三种集合类型，分别是：序列Seq、集合Set、映射Map，它们都来自Iterable特质

2.都提供了可变和不可变两种版本：immutable指不可变的集合，mutable指可变集合

不可变就是指：每次修改集合后会产生一个新的集合

可变就是指：每次修改是在原有集合上做的修改

3.整体继承树（图来自尚硅谷资料）

1.不可变集合

2.可变集合

数组

1.不可变的数组

①定义：val arr = new Array[Int](10)

new关键字

[Int]指该数组存放数据的类型，类似于Java中的 <> 也就是泛型的意思

(10)指数组容量的大小，该值确定后不可改变

取值：arr(2) //角标默认是从 0 开始的

遍历：

//用逗号分割数组中的元素
println(arr.mkString(","))

//遍历输出
for (i <- arr) {
    println(i)
}

②val arr1 = Array(1, 3, 2)

在创建数组的同时给数组赋初值，arr1(0）= 1, arr(1) = 3, arr(2) = 2

使用的是 apply 创建数组。正常情况下需要使用 new 关键字创建数组

2.可变数组

①定义：var arr = ArrayBuffer[Any](2, 1, 3)

需要使用mutable包下的数组集合

使用append关键字来向集合中添加元素，可以一次性追加多个元素 arr.append(5, 4)

数据按添加的顺序进行存放

不可变数组和可变数组的互转

arr.toBuffer //不可变数组转化为可变数组

arr1.toArray //可变数组转化为不可变数组

它们都是返回一个新的数组，本身没有变化

有一维数组，那必不可少的也会有多维数组

定义：var arr = Array.ofDim[Double](3, 4)

二维数组中有三个以为数组，每个一维数组中有4个元素

scala 默认给我们提供了5维数组，也就是我们可以定义到5维，再高就需要自定义

List列表

1.不可变（默认）

list是按照添加元素的顺序进行排列，数据可重复

在遍历List的时候可以使用for循环，也可以使用foreach

list.foreach(println) //可以打印集合

在向List中添加元素的时候，可以使用 ::

如向list中添加数据：1::2::3::4::list

:: 默认是从右往左添加的，上述，1234会出现在list的头部

集合之间的合并：将集合拆成一个一个的个体，称为扁平化

如将 list 和 list1 进行合并：var list2 = list:::list1

三个（:::)冒号

取指定位置的数据：list(0), list(1)。。。角标默认是从 0 开始的

2.可变

ListBuffer

定义：var list = ListBuffer(1, 3, 2, 4)

添加：如果向集合中添加元素可以使用，.+=(x)、append 、insert 三种方法

打印：list.foreach(println)

修改：list.update(a, x) 将a位置上的元素修改成x

删除：list.remove(a) 删除a位置上的元素

Set集合

不可变

默认情况下的 Set 是不可变的，如果想要可变的 Set 需要引入 mutable 包下的类

特点：数据无序，不可重复。无序指的是打印的顺序不是按插入的顺序打印的，是按哈希值进行排序的

定义：var set: Set = Set(1, 2, 3, 4, 5, 5)

打印：for(x <- set) println(x)、set.foreach(println)、println(set.mkString(","))

可变

注意：导包的时候要导入 mutable 包

定义：var set: Set = Set(1, 2, 3, 4, 5, 5)

添加：set += 7

删除：set -= 4

Map

不可变

可变不可变的定义同上

定义：val map = Map("a"->1,"b"->2,"c"->3)

访问：

for (elem <- map.keys) {
    使用 get 访问数据的时候会返回特殊的类型 Option（选项）：有值(Some)、无值(None)
    println(elem + "=" + map.get(elem).get)
}

如果可以不存在，则放回 0 ：println(map.get("d").getOrElse(0)) 或者 println(map.getOrElse("d", 0))

循环打印：map.foreach((kv)=>{println(kv)})

可变

定义：val map = mutable.Map("a"->1, "b"->2, "c"->3)

添加：map.+=("d"->4)、map.put("e", 5)

删除：map.-=("a", "b") //只操作对应的 key 即可

修改：map.update("c", 10)、map("d", 11)

打印：map.foreach((kv)=>{println(kv)})

map中的键值对其实就是元组，只不过元组元素的个数为2，称之为对偶

元组

定义：元组可以理解为一个容器，可以存放各种相同或不同类型的数据。说简单点，就是将多个无关的数据封装成为一个整体，称为元组

底层元组最大封装的元素有 22 个

声明：val tuple: (Int, String, Boolean) = (40, "Tom", true)

访问：

①通过元素的顺序进行访问，调用方式： _ 顺序号

println(tuple._1)

println(tuple._2)

println(tuple._3)

②通过索引访问数据

println(tuple.productElement(0))

③通过迭代器进行访问

for (elem <- tuple.productIterator) {

println(elem)

}

特殊的元组：Map

val map = Map("a"->1, "b"->2, "c"->3)

//val map = Map(("a",1), ("b",2), ("c",3))

map.foreach(tuple=>{println(tuple._1 + "=" + tuple._2)})

集合操作

1.集合常用操作

获取集合长度：length

获取集合大小：size()

循环遍历：for (elem <- xxx) println(elem)

迭代器：for (elem <- xxx.iterator) println(elem)

生成字符串：println(xxx.mkString(","))

是否包含：println(xxx.contains(x))

2.衍生集合

获取集合的头
```
println(list.head)
```
获取集合的尾（不是头的就是尾）
```
println(list.tail)
```
集合最后一个数据
```
println(list.last)
```
集合初始数据（不包含最后一个）
```
println(list.init)
```
反转
```
println(list.reverse)
```

取前（后）n 个元素

前
println(list.take(3))
后
println(list.takeRight(3))

去掉前（后）n 个元素

前
println(list.drop(3))
后
println(list.dropRight(3))

并集
```
println(list.union(list1))
```
交集
```
println(list.intersect(list1))
```
差集
```
println(list.diff(list1))
```

拉链

//如果两个集合元素个数不相等，那么会将同等数量的数据进行拉链，多余的数据省略不用
println(list.zip(list1))

滑窗

//窗口大小为2，每次滑动5格
list.sliding(2, 5).foreach(println)

3.计算函数

求和
```
println(list.sum)
```
求乘积
```
println(list.product)
```
最大值
```
println(list.max)
```
最小值
```
println(list.min)
```
排序

//按照元素大小排序
println(list.sortBy(x => x)

//按照元素的绝对值大小排序
println(list.sortBy(x => x.abs)

//按照元素大小升序排列
println(list.sortWith((x, y) => x < y))

//按照元素大小降序排序
println(list.soryWith((x, y) => x > y))

sorted

对一个集合进行自然排序，通过传递隐式的 Ordering

sortBy

对一个属性或多个属性进行排序，通过它的类型

sortWith

基于函数的排序，通过一个 comparator 函数，实现自定义排序的逻辑

过滤
```
println(list.filter(x => x % 2 == 0))
```
转化/映射
```
println(list.map(x => x + 1))
```

扁平化

//将多个集合中的元素拆成一个一个的元素
val list: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
println(list.flatten)

扁平化+映射:flatMap 相当于先进行 map 操作，再进行 flatten 操作

val word: List[String] = List("hello world", "hello spark", "hello scala")
println(word, flatMap(x => x.split(" "))

分组
```
println(list.groupBy(x => x % 2))
```

简化/归约

//reduce：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最终获取结果
val i: Int = list.reduce((x, y) => x - y)

// 从源码的角度，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)