scala集合算子大全及分类汇总——倾心整理
Posted Z-hhhhh
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了scala集合算子大全及分类汇总——倾心整理相关的知识，希望对你有一定的参考价值。
++
合并集合，返回新的数组
val arr1=Array(1,2,3)
val arr2=Array(4,5,6)
val arr3=arr1++arr2
arr3.foreach(println)
//结果
1
2
3
4
5
6
++：
合并集合，右边的集合决定返回的类型
这个方法，不能在Ideal中运行，只能在虚拟机的scala中执行
+:
在集合的头部添加元素，一次只能加一个元素，可以叠加使用
val arr1=Array(1,2,3)
val arr3 = 1 +: arr1
arr3.foreach(println)
//结果
1
1
2
3
:+
与+:相反，在头部添加元素，也可以叠加使用
val arr1=Array(1,2,3)
val arr3 = arr1 :+ 4 :+ 5
arr3.foreach(println)
//结果
1
2
3
4
/:
对集合中所有的元素从左到右遍历，进行相同的迭代操作，与foldLeft,reduceLegt相似（_运算符_）
var arr1=Array(2,4,7,3,9,10)
val i: Int = (1 /: arr1) (_ + _)
println(i)
//结果，累加：1+2+4+7+3+9+10=36
36
:\\
对集合中所有的元素从右向左遍历，进行相同的迭代操作，与foldRight,reduceRight相似
var arr1=Array(2,4,7,3,9,10)
val i: Int = (arr1 :\\ 1) (_ + _)
println(i)
//结果
36
注意：这里写的都是加法，所以结果相同，如果是减法或者除法 结果是截然不同的，因为它是由顺序的，一个是从参数开始从左到右，一个是从右到左，参数最后
addString
讲数组中的元素添加到StringBuilder中
val arr1=Array(1,2,3)
val arr2=ArrayBuffer(4,5,6,2)
val builder = new StringBuilder
val str = arr1.addString(builder)
println(str)
//builder 会记忆
builder.clear()
//将数组添加到StringBuilder中，用指定的分隔符分割，
val str1 = arr1.addString(builder, ",")
println(str1)
//结果
123
1,2,3
aggregate
聚合计算，aggregate是柯里化方法，参数是两个办法(在不分区时，把初始值和每个元素相加，得到的加过与下一个元素进行运算，分区时，在以上步骤，多加一个combine过程)
def f1 (x:Int,y:Int) ={
println(s"$x+$y=${x+y}")
x+y
}
def f2 (x:Int,y:Int)={
println(s"$x+$y=${x+y}")
x+y
}
val arr =Array(1,2,3,4)
//不分区的情况下
println(arr.aggregate(2)(f1, f2))
println("=================")
//分区
println((arr).aggregate(3)(f1, f2))
//结果
2+1=3
3+2=5
5+3=8
8+4=12
12
=================
3+1=4
4+2=6
6+3=9
9+4=13
13
//以上写发是为了能够显示出计算过程，实际平时采用以下的方式
println(arr.aggregate(2)(_ + _, _ + _))
println(arr.par.aggregate(3)(_ + _, _ + _))
andThen
拼接两个函数,andThen 可以接 andThen,先执行前面，后执行后面的
val f1 = (x:Int) => x+2
val f2 = (x:Int) => x*2
val f3 = f1 andThen(f2)
println(f3(1))
val f1 = (x:Int) => x+2
val f2 = (x:Int) => x*2
val f3 = (x:Int) => x-1
val f4 = f1 andThen(f2) andThen (f3)
println(f4(1))
apply
取指定下标对应的元素
var arr1=Array(2,4,7,3,9)
println(arr1.apply(2))
//结果
7
applyOrElse
有两个参数，参数和回调函数，如果参数匹配，则返回参数角标对应的值，否则参数进入到回调函数中
val arr1=Array(1,2,3)
//1在范围内，所以返回下标对应的值
println(arr1.applyOrElse(1, (ix: Int) => ix))
//4越界了，则进入到函数中，所以返回4
println(arr1.applyOrElse(4, (ix: Int) => ix))
//结果，
2
4
canEqual
判断两个对象是否可以进行比较，知道的都是true，貌似没啥用
charAt
取指定下标的元素，类似于apply，不过它只针对char类型，其他类型没有这个方法
val chars: Array[Char] = Array('a', 'c', 's')
println(chars.charAt(1))
//结果
c
clone
克隆集合，返回新的集合，克隆后的数组虽然元素与原来数组相同，但是 == 和 equals不相同，
var arr1=Array(2,4,7,3,9,10)
val narr = arr1.clone()
narr.foreach(println)
println(arr1 == narr)
println(arr1.equals(narr))
//结果
2
4
7
3
9
10
false
false
collect
执行一个并行计算(偏函数)，得到一个新的数组对象(通过偏函数对某些元素进行操作)
val pf :PartialFunction[Int,Int] = (x:Int)=>x match {
case x if (x%2==1) =>x
}
arr1.collect(pf).foreach(println)
//上下两种写发相同,提取集合中符合条件的元素，类似于filter
arr1.collect( {case x if (x%2==1) =>x}).foreach(println)
//提取集合中第一个符合条件的元素 返回option
println(arr1.collectFirst({ case x if (x>10) => x }))
collectFirst
找到第一个符合偏函数定义的元素，并计算，
//提取集合中第一个符合条件的元素 返回option
println(arr1.collectFirst({ case x if (x>10) => x }))
combinations
根据制定组合个数，进行排列组合，且不考虑顺序，返回一个迭代器，需要遍历查看，如果有重复，会把重复的去掉
val arr =Array(1,2,3,4,1)
arr.combinations(2).foreach(x=>println(x.mkString(",")))
//结果
1,1
1,2
1,3
1,4
2,3
2,4
3,4
compaion
获得集合的类型
println(arr1.companion.getClass)
//结果
class scala.collection.mutable.IndexedSeq$
compose
表示方法的连续调用，与 andThen 相反，不同的是需满足第二个函数的返回值类型是第一个函数的输入值类型
contains
判断集合是否包含指定元素
val arr =Array(1,2,3,4,1)
println(arr.contains(1))
//结果
true
containsSlice
判断集合是否包含对应的集合
val arr1 = Array(1, 2, 3, 5,1,2)
println(arr1.containsSlice(Array(1, 2)))
//结果
true
copyToArray
复制当前集合到另外一个集合当中（要求类型需要一致），无返回值
注意：arr2这里写0是为了占位，如果arr2比arr的长度短，arr那么后面的元素将无法复制到arr2中，反之，如果arr2比arr长，那么最后的地方，将还是0（无法覆盖了），简而言之，就是对应下标覆盖
val arr =Array(1,2,3,4,1)
val arr2:Array[Int] =Array(0,0,0,0,0)
arr.copyToArray(arr2)
arr2.foreach(println)
//结果
1
2
3
4
1
//验证一下上面的注意事项
//arr2比较短的情况
val arr =Array(1,2,3,4,1)
val arr2:Array[Int] =Array(0,0,0)
arr.copyToArray(arr2)
arr2.foreach(println)
//结果
1
2
3
//arr2比较长的情况
val arr =Array(1,2,3,4,1)
val arr2:Array[Int] =Array(0,0,0,0,0,0,3)
arr.copyToArray(arr2)
arr2.foreach(println)
//结果
1
2
3
4
1
0
3
//确实是对应下标覆盖，不足的地方就不改变
//copyToArray(arr,start) 从start开始，直到全部拷贝，或者目标数组已经填满了
//copyToArray(arr,start,len)，从start开始，拷贝长度为len的个数，
copyToBuffer
将数组中的元素复制到Buffer中，类型需要一致，
这里需要单独导包import scala.collection.mutable.ArrayBuffer
val arr:Array[Int] =Array(1,2,3,4,1)
import scala.collection.mutable.ArrayBuffer
val arr2 = new ArrayBuffer[Int]()
arr.copyToBuffer(arr2)
corresponds
判断两个数组长度是否相等，以及对应位置的元素是否符合某个条件，如果都满足返回true，
val arr:Array[Int] =Array(1,2,3,4,1)
val arr2 =Array(2,5,4,6,2)
println(arr.corresponds(arr2)(_ < _))
//结果
true
count
统计符合条件的元素个数
val arr:Array[Int] =Array(1,2,3,4,1)
println(arr.count(x => x % 2 == 0))
//结果
2
diff
取集合的差集，
val arr:Array[Int] =Array(1,2,3,4,1)
val arr1 = Array(2,3,5,6)
arr.diff(arr1).foreach(x=>print(x+"\\t"))
//结果
1 4 1
distinct
集合去重，返回一个新集合
val arr:Array[Int] =Array(1,2,3,4,1)
arr.distinct.foreach(println)
//结果
1
2
3
4
drop
将当前数组中的前n个元素删除，返回一个新的数组(与head，init,last,tail,take 相似)
val arr:Array[Int] =Array(1,2,3,4,1)
arr.drop(2).foreach(println)
//结果
3
4
1
dropRight
将当前数组的后n个元素去除
val arr:Array[Int] =Array(1,2,3,4,1)
arr.dropRight(2).foreach(println)
//结果
1
2
3
dropWhile
去除集合中符合条件的元素，返回剩余的元素，从第一个满足条件的元素开始删除，遇到不满足条件的就删除。如果第一个就不满足，则一个也不删除
val arr2 = ArrayBuffer(4, 5, 6, 2)
arr1.dropWhile(_<3).foreach(println)
//结果
3
5
1
2
endWith
判断序列是否以某个序列结尾，返回布尔值,参数是一个序列
val arr:Array[Int] =Array(1,2,3,4,1)
println(arr.endsWith(Array(1)))
//结果
true
exists
判断集合是否存在有满足条件的
val arr:Array[Int] =Array(1,2,3,4,1)
println(arr.exists((p: Int) => p % 2 == 0))
filter
过滤，取出当前元素中所有符合条件的元素，组成一个新的集合
val arr:Array[Int] =Array(1,2,3,4,1)
val ints = arr.filter(_ % 2 == 0)
ints.foreach(println)
//结果
2
4
filterNot
与filter相反，把不符合条件的筛选出来
var arr1=Array(2,4,7,3,9,10)
arr1.filterNot(_%2==0).foreach(println)
//结果
7
3
9
find
找到集合中第一个符合条件的元素值，返回值类型是option
val arr1 = Array(1, 2, 3, 5,1,2)
val maybeInt: Option[Int] = arr1.find((x: Int) => x % 2 == 0)
maybeInt.foreach(println)
//结果
2
flatMap
对当前序列的每个元素进行操作，返回一个新序列（理解成先map再flatten）
var arr3=Array(Array(1,28,4),Array(4,20,5))
arr3.flatMap(x => x.map(y => y + 1)).foreach(println)
//或者用下面的写法更优雅
arr3.flatMap(_.map(_+1)).foreach(println)
//结果
2
29
5
5
21
6
flatten
对数组降低一个维度
var arr2=Array(Array("孙悟空",28,"赛亚人"),Array("18号",20,"人造人"))
//不使用flatten
arr2.foreach(x=>x.foreach(println))
println("================")
//使用flatten
arr2.flatten.foreach(println)
//结果
孙悟空
28
赛亚人
18号
20
人造人
================
孙悟空
28
赛亚人
18号
20
人造人
fold
对序列中的每个元素进行二元运算
val arr:Array[Int] =Array(1,2,3,4,1)
def f (x:Int,y:Int)={
println(s"${x}+${y}=${x+y}")
x+y
}
println(arrJava基础到就业！项目加面试！之Redis面试大全！倾心整理建议收藏