Spark学习笔记(7)——RDD行动算子

RDD方法又称RDD算子。

算子 ： Operator（操作）
RDD的方法和Scala集合对象的方法不一样，集合对象的方法都是在同一个节点的内存中完成的。RDD的方法可以将计算逻辑发送到Executor端（分布式节点）执行，为了区分不同的处理效果，所以将RDD的方法称之为算子。RDD的方法外部的操作都是在Driver端执行的，而方法内部的逻辑代码是在Executor端执行。

RDD的常用方法分为两大类：转换和行动

• 转换就是将旧的RDD包装成新的RDD，实现功能的补充和封装。比如flatMap和map方法
• 行动就是触发任务的调度和作业的执行，比如collect方法

RDD行动算子

(1) reduce

➢ 函数签名

def reduce(f: (T, T) => T): T

➢ 函数说明
聚集 RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 聚合数据
val reduceResult: Int = rdd.reduce(_+_)

(2) collect

➢ 函数签名

def collect(): Array[T]

➢ 函数说明
在驱动程序中，以数组 Array 的形式返回数据集的所有元素

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 收集数据到 Driver
rdd.collect().foreach(println)

需要注意rdd.collect().foreach()和rdd.foreach()的区别，rdd.collect().foreach()是将数据按顺序收集到driver端然后循环遍历，而rdd.foreach()是在各个Executor端分布式循环遍历

(3) count

➢ 函数签名

def count(): Long

➢ 函数说明
返回 RDD 中元素的个数。数据量大时不要用此方法，性能非常低

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val countResult: Long = rdd.count()

(4) first

➢ 函数签名

def first(): T

➢ 函数说明
返回 RDD 中的第一个元素

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val firstResult: Int = rdd.first()
println(firstResult)

(5) take

➢ 函数签名

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

➢ 函数说明
返回一个由 RDD 的前 n 个元素组成的数组

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val takeResult: Array[Int] = rdd.take(2)
println(takeResult.mkString(","))

(6) takeOrdered

➢ 函数签名

def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]

➢ 函数说明
返回该 RDD 排序后的前 n 个元素组成的数组

val rdd: RDD[Int] = sc.makeRDD(List(1,3,2,4))
// 返回 RDD 中元素的个数
val result: Array[Int] = rdd.takeOrdered(2)

(7)aggregate

➢ 函数签名

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U

➢ 函数说明
分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合

val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 8)
// 将该 RDD 所有元素相加得到结果
//val result: Int = rdd.aggregate(0)(_ + _, _ + _)
val result: Int = rdd.aggregate(10)(_ + _, _ + _)

aggregateByKey：初始值只会参与分区内计算
aggregate：初始值会参与分区内计算，并且参与分区间计算

reduceByKey、aggregateByKey在shuffle之前可能会先进行聚合，聚合后的数据再进行shuffle，这样一来进行shuffle的数据会变少，速度会快。
reduceByKey、aggregateByKey的区别是前者不同partition以及partition之间的聚合操作是一样的，而后者可以指定两种操作来对应于- —partition之间和partition内部不同的聚合操作，并且aggregateByKey可以指定初始值。
在aggregateByKey中，如果两种操作是一样的，可以使用foldByKey来代替，并且只传一个操作函数。foldBykey和reudceBykey的区别是前者可以指定一个初始值。

(8) fold

➢ 函数签名

def fold(zeroValue: T)(op: (T, T) => T): T

➢ 函数说明
折叠操作，aggregate 的简化版操作

val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
val foldResult: Int = rdd.fold(0)(_+_)

(9) countByKey

➢ 函数签名

def countByKey(): Map[K, Long]

➢ 函数说明
统计每种 key 的个数

val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2, 
"b"), (3, "c"), (3, "c")))
// 统计每种 key 的个数
val result: collection.Map[Int, Long] = rdd.countByKey()

(10) save 相关算子

➢ 函数签名

def saveAsTextFile(path: String): Unit
def saveAsObjectFile(path: String): Unit
def saveAsSequenceFile(
 path: String,
 codec: Option[Class[_ <: CompressionCodec]] = None): Unit

➢ 函数说明
将数据保存到不同格式的文件中

// 保存成 Text 文件
rdd.saveAsTextFile("output")
// 序列化成对象保存到文件
rdd.saveAsObjectFile("output1")
// 保存成 Sequencefile 文件,要求数据格式为K-V类型
rdd.map((_,1)).saveAsSequenceFile("output2")

(11) foreach

➢ 函数签名

def foreach(f: T => Unit): Unit = withScope {
 val cleanF = sc.clean(f)
 sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF))
}

➢ 函数说明
分布式遍历 RDD 中的每一个元素，调用指定函数

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 收集后打印，这里的foreach是Driver端内存集合的循环遍历方法
rdd.map(num=>num).collect().foreach(println)
println("****************")
// 分布式打印，这里的foreach是Executor端内存数据的循环遍历方法
//由于各节点的执行顺序不定，因此数据打印的顺序也是不确定的
rdd.foreach(println)