目录
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)
队列
scala也有队列的定义同样也有可变和不可变两种,特点是先进先出 FIFO 。进队和出队的方法分别是:enqueue、dequeue
并行集合
Scala 为了充分使用多核 CPU,提供了并行集合(有别于前面的串行集合),用于多核环境的并行计算。
再方法执行前加上 par 就可以开启