spark算子

spark 算子

提取元素

def head:T

提取头元素

def headOption:Option[T]

提取头元素，若数组为空则返回None，解决数组为空引发报错的问题

def last : T

提取尾元素

def lastOption: Option[T]

提取尾元素， 若数组为空则返回None，解决数组为空引发报错的问题

val arr = Array(12,11)
val arr1:Array[Int] = Array()
println(arr.head)
println(arr.headOption)
println(arr1.headOption)
println(arr.last)
println(arr.lastOption)

12
Some(12)
None
11
Some(11)

def apply(i:Int) :T

取出指定下标的元素

def applyOrElse(i:Int, f:(x:Int)=>{…}) T

提取改下标的元素，如果越界，则将参数1传入参数2的函数中

val arr = Array(1,3,4,5)
    println(arr.indexOf(1))
    println(arr.applyOrElse(10,(x:Int) => 2))

0
2

def take(size:Int) :Array[T]

从左提取size个元素

def takeRight(size:Int) :Array[T]

从右边提取size个元素

def takeWhile(f:T=> Boolean) :Array[T]

当一个元素满足条件时，返回当前序列中满足条件的连续元素，至不符合条件结束

def filter(f:T=> boolean): Array[T]

提取集合中所有满足条件的元素

def filterNot(f:T => boolean):Array[T]

提取集合中所有不满足条件的元素

def collect(PartialFunction[T,B]:T =>B )

提取集合中所有满足参数偏函数条件的元素

   val arr = Array(1,3,4,5,1)
    arr.collect({
   case x if(x>2) => {
   x*2}}).foreach(println)

6
8
10

def collectFirst(PartialFunction[T,B]:T=> )

提取集合中第一个满足参数偏函数条件的元素

def find(f:T=>Boolean) :Option[T]

提取集合中第一个满足参数偏函数的元素

def slice(from: Int, Util:Int)

提取集合从from 到 util 之间的所有元素，前包后不包

def init :Array[T]

提取除最后一元素外的所有元素，空集合报错

def inits

返回迭代器 ，递归提取除最后一个元素外的所有元素，并封装为迭代器返回

val arr = Array(1,3,4,5,1)
  arr.inits.foreach(x=>println(x.mkString(",")))

1,3,4,5,1
1,3,4,5
1,3,4
1,3
1

tail ：Array[T]

提取除第一个元素外的所有元素

tails

递归提取除第一个元素外的所有元素的迭代器

def lift :

def orElse(f:partialFunction[T,B])

返回根据参数偏函数规则提取数组元素的偏函数

修改操作

def update(index:Int, newV:T)

修改index位置的元素为newV 越界报错

def update(index:Int, newV:T) Array[T]

修改index位置的元素为newV,并将修改后的数组返回

def ++|union 并集

def ++: 并集

：后面的类型决定返回值类型

def itersect(Arrar[T]) ) 交集

返回类型由前面的数组类型决定

def diff 差集

:+ 尾部追加

+: 头部追加

def drop(n:Int) :Array[T] 头删除n个元素

def dropRight(n:Int) 从右边删除n个元素

def dropWhile(P:Int =>Boolean)

当第一个元素满足条件开始删除连续的满足条件的元素至不满足条件时结束

def patch(from:Int,sub:Gensq,replaceLen:Int)

从from开始 ，将原序列replaceLen个元素替换为序列sub，sub长度大于replaceLen时原序列扩容，否则长度减小

val arr = Array(1,3,4,5,1)
    val list = List(1,2,3)
    arr.patch(2,list,5).foreach(println)

1
3
1
2
3

逐个迭代处理

def map(f:T=>B )

def reverseMap(f:T=>B)

反向map

	val arr = Array(1,3,4,5,1)
    arr.reverseMap(x=>x+10).foreach(println)
    ------------------
    11
    15
	14
	13
	11

def transform(f:T=>B)

def flatten :Array[T]

数组降维，返回一个一维数组

def flatMap (f:T=>B)

先进行map ，在进行降维，对序列内的元素进行操作返回一个新序列

分组

def par :ParArray[T]

返回一个并行序列且不能不修改，其作用相当于hashcode进行分组

	val arr = Array(1,