Spark一路火花带闪电——Spark常用算子(参数及其返回值)探究
文章目录
- 转化算子
- 行动算子
转化算子
以数据Seq(1,2,3,3)为例子
- map(f:T => U):RDD[U]
映射：将函数应用于RDD内的每个元素，将其返回值构成新的RDD
rdd.map(_+1)
>> 2,3,4,4
- flatMap(f:T => U):RDD[U]
映射：将函数应用于RDD内的每个元素，将返回的迭代器的所有内容构成新的RDD，通常用来切分单词
txt.flatMap(_.split("\n")) //切分单词
rdd.flatMap(_ to 3)
>>1,2,3,2,3,3,3
- fliter(f:T => Boolean):RDD[T]
过滤
rdd.filter(_>2)
>>3,3
- distinct():RDD[T]
去重
rdd.distinct()
>>1,2,3
- sample(withReplacement : Boolean, fraction : Double, [seed : Long]):RDD[T]
随机采样：函数参数表示【是否替换，抖动，随机数种子】
rdd.sample(false,0.5)表示不替换，每个元素被选到的概率是0.5，本例中选出的元素数目的期望是2
>>1,3,3
rdd.sample(true,2)抖动大于1时，必须替换，本例中一定选出8个元素
>>3,3,3,3,3,1,1,1,1,2,2,3
以数据Seq(1,2,3)和数据Seq(3,4,5)为例
- union(other : RDD[T]):RDD[T]
取并集A∪B
rdd1.union(rdd2)
>>1,2,3,3,4,5
- intersection(other : RDD[T]):RDD[T]
取交集A∩B
rdd1.intersection(rdd2)
>>3
- subtract(other : RDD[T]):RDD[T]
集合差A-B
rdd1.subtract(rdd2)
>>1,2
- cartesian(other : RDD[U]):RDD[T,U]
笛卡尔积
rdd1.cartesian(rdd2)
>>{(1,3),(1,4)...........}
行动算子
以Seq(1,2,3,3)为例子
- collect():Array[T]
返回RDD中所有元素，通常在小的数据集合中使用，因为它要求所有数据都必须能一同放入单台机器的内存中
rdd.collect()
>>Array(1,2,3,3)
- count():Long
返回RDD内元素的数目
rdd.count()
>>4L
- countByValue():Map[T,Long]
返回各个元素出现的次数
rdd.count()
Map{(1,1),(2,1),(3,2)}
- take(num:Int):Array[T]
take用于获取RDD中从0到num-1下标的元素，不排序
rdd.take(2)
>>Array{1,2}
- top(num:Int):Array[T]
top按照默认（降序）或者指定的排序规则，返回前num个元素
rdd.top(2)
>>Array{3,3}
- takeOrdered(num:Int)(implicit ord :Ordering[T]):Array[T]
takeOrdered和top类似，只不过以和top相反的顺序返回元素
implicit object PersonOrdering extends Ordering[Person] {
override def compare(p1: Person, p2: Person): Int = {
p1.name == p2.name match {
case false => -p1.name.compareTo(p2.name)
case _ => p1.age - p2.age
}
}
}
val p1 = new Person("rain", 13)
val p2 = new Person("rain", 14)
import Ordered._
p1 < p2 // True
rdd.takeOrdered(2)(myOrdering)
- takeSample(withReplacement : Boolean, fraction : Double, [seed : Long]):Array[T]
与之前sample()函数差不多，只不过这是行动算子
- foreach(f:T => Unit):Unit
对RDD内的每个元素都使用函数f
rdd.foreach(print)
或者
rdd.foreach(print(_))
- reduce(f:(T,T) => T): T
并行整合RDD中所有数据
rdd.reduce((x,y)=>x+y)
>> 9
- fold(zeroValue : T)(f:(T,T) => T): T
与reduce()相似，提供初始值，加法初始值应为0，乘法初始值应为1。(zeroValue意义：1、初值；2、保存中间结果)
rdd.fold(0)((x,y)=>x+y)
>> 9
rdd.fold(1)((x,y)=>x*y)
>>18
- aggregate(zeroValue : U)(SeqOp:(U,T)=>U, comOp:(U,U)=>U):U
reduce()和fold()这两个函数它们的返回值必须与rdd的数据类型相同，aggregate()函数就打破了这个限制，rdd数据类型是T，返回类型可以是U。
seqOp：针对每个分区（节点）的操作函数
combOp：在seqOp对每个分区操作完成之后，将每个分区的结果进行整合，从而求出最后的结果
rdd_seq.aggregate((0,0))((x,y)=>(x._1+y,x._2+1),(x,y)=>(x._1+y._1,x._2+y._2))其中第一步SeqOp里，x是元组，y是Seq(1,2,3,3)里的值。第二步x,y都是元组，只不过需要将每个分区的值合并。这段代码是求的元素总的值和数目。
Tuple(9,4)输入是int，输出是元组。