Spark常用算子

Transformation转换算子

Value类型

• map映射

• def map[U: ClassTag](f: T => U): RDD[U]

• mapPartitions以分区为单位执行map

• def mapPartitions[U: ClassTag](f: Iterator[T] => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]

• map与mapPartitions区别

• map每次处理一条数据

• mapPartitions每次处理一个分区的数据，这个分区的数据处理完后，原RDD中分区的数据才能释放，可能导致OOM

• 当内存空间较大的时候建议使用mapPartitions，以提高处理效率

• mapPartitionsWithIndex带分区号

• def mapPartitionsWithIndex[U: ClassTag](f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]

• flatMap压平

• def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

• glom分区转换数组

• def glom(): RDD[Array[T]]

• groupBy分组

• def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

• groupBy存在shuffle过程（将不同的分区数据进行打乱重组的过程）

• filter过滤：def filter(f: T => Boolean): RDD[T]

• sample采样

• def sample(withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T]

• withReplacement：是否可以重复采样

• fraction：不可以重复采样，选择每个元素的概率，取值范围[0,1]；可以重复采样，选择每个元素的期望次数，取值必须大于等于0

• distinct去重

• def distinct(): RDD[T]

• 默认情况下，distinct会生成与原RDD分区个数一致的分区数，也可以传指定的分区数

• coalesce重新分区

• def coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null): RDD[T]

• 默认不执行shuffle，可以选择是否执行shuffle

• 一般为缩减分区数，用于大数据集过滤后，提高小数据及的执行效率

• repartition重新分区（执行shuffle）

• def repartition(numPartitions: Int) (implicit ord: Ordering[T] = null): RDD[T]

• repartition实际上调用的coalesce，进行shuffle

• 一般用于扩大分区

• coalesce与repartition区别

• coalesce重新分区，可以选择是否进行shuffle过程。由参数shuffle: Boolean = false/true决定

• repartition实际上是调用的coalesce，进行shuffle

• coalesce一般为缩减分区，如果扩大分区，不使用shuffle是没有意义的，repartition扩大分区执行shuffle

• sortBy排序

• def sortBy[K]( f: (T) => K, ascending: Boolean = true, numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

• 默认正序，排序后新产生的RDD的分区数与原RDD的分区数一致

• pipe调用脚本

• def pipe(command: String): RDD[String]

• 脚本需放置在worker节点可以访问到的位置

双Value类型交互

• union并集

• def union(other: RDD[T]): RDD[T]

• 与数学上的并集意义不一样，只是合并数据

• subtract差集

• def subtract(other: RDD[T]): RDD[T]

• 去除方法调用者中两者相同数据，将剩下的数据返回

• intersection交集

• def intersection(other: RDD[T]): RDD[T]

• 返回两者相同的数据，但是会去重，比如调用者含有两个相同元素A，other也含有两个相同元素A，返回结果只有一个A

• zip拉链

• def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]

• 将两个RDD组合成元祖，两个RDD的partition数量以及元素数量都相同，否则会抛出异常

Key-Value类型

• partitionBy按照K重新分区

• def partitionBy(partitioner: Partitioner): RDD[(K, V)]

• 将RDD[K, V]中的K按照指定的Partitioner重新分区，如果原有的partitioner和现有的partitioner是一致的话就不进行分区，否则会产生shuffle过程

• reduceByKey按照K聚合V

• def reduceByKey(func: (V, V) => V): RDD[(K, V)]

• groupByKey按照K重新分组

• def groupByKey(): RDD[(K, Iterable[V])]

• reduceByKey和groupByKey区别

• reduceByKey：按照key进行聚合，在shuffle之前有combine（预聚合）操作，返回结果是RDD[K, V]

• groupByKey：按照key进行分组，直接进行shuffle

• 在不影响业务逻辑的前提下，优先选用reduceByKey。求和操作不影响业务逻辑，求平均值影响业务逻辑。

• aggregateByKey 按照K处理分区内核分区间逻辑

• def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]

• zeroValue：初始值，给每一个分区中的每一种key一个初始值

• seqOp：分区内，用于在分区内用初始值逐步迭代value

• combOp：分区间，用于合并每个分区中的结果

• foldByKey 分区内和分区间相同的aggregateByKey

• def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

• aggregateByKey的简化操作，分区内和分区间逻辑相同

• combineByKey转换结构后分区内和分区间操作

• def combineByKey[C]( createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C): RDD[(K, C)]

• createCombiner：将第一个读进来的数据转换为想要的数据格式

• mergeValue：分区内的合并函数，主要是将V合并到之前的createCombiner的元素C上

• mergeCombiners：分区间的合并函数

• reduceByKey、aggregateByKey、foldByKey、combineByKey

• reduceByKey----初始值不变

• combineByKeyWithClassTag[V]((v: V) => v, func, func, partitioner)

• aggregateByKey----初始值和分区内处理规则一致

• combineByKeyWithClassTag[U]((v: V) => cleanedSeqOp(createZero(), v), cleanedSeqOp, combOp, partitioner)

• foldByKey----分区内和分区间规则一致

• combineByKeyWithClassTag[V]((v: V) => cleanedFunc(createZero(), v), cleanedFunc, cleanedFunc, partitioner)

• combineByKey----把第一个值变成特定的结构

• combineByKeyWithClassTag(createCombiner, mergeValue, mergeCombiners)(null)

• sortByKey按照K排序

• def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length): RDD[(K, V)]

• mapValues只对V进行操作

• def mapValues[U](f: V => U): RDD[(K, U)]

• join连接 将相同K对应的多个V关联在一起

• def join[W](other: RDD[(K, W)], partitioner: Partitioner): RDD[(K, (V, W))]

• def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

• 遍历RDD1中元素，与RDD2中元素匹配，K匹配上就返回一个结果，至全部匹配后继续遍历下一个元素（即新的RDD中某个K的个数等于RDD1中K的个数乘以RDD2中K的个数），如果K只是某一个RDD有，这个K不会关联

• cogroup类似全连接，但是在同一个RDD中对K聚合

• def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]

• 在类型为(K, V)和(K, W)的RDD上调用，返回一个(K, (Iterable[V], Iterable[W]))类型的RDD

Action行动算子

• reduce聚合

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

• 聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据

• collect以数组的形式返回数据集

• def collect(): Array[T]

• Executor计算结果收集到Driver端，慎用！

• count返回RDD中元素个数

• def count(): Long

• first返回RDD中第一个元素

• def first(): T

• take返回由RDD前n个元素组成的数组

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

• takeOrdered返回该RDD排序后前n个元素组成的数组

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

• aggregate聚合

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

• 将每个分区内的元素通过分区内逻辑和初始值进行聚合，然后用分区间逻辑和初始值进行操作

• aggregate与aggregateByKey区别

• aggregate是行动算子，aggregateByKey是转换算子

• 分区间聚合的时候，aggregate初始值参与运算，aggregateByKey初始值不参与运算

• fold聚合 aggregate的简化操作

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

• 分区内逻辑与分区间逻辑相同

• fold与foldByKey区别

• fold是行动算子，foldByKey是转换算子

• 分区间聚合的时候，fold初始值参与运算，foldByKey初始值不参与运算

• countByKey统计每种K的个数

• def countByKey(): Map[K, Long]

• save相关算子

• saveAsTextFile(path)保存成Text文件

• 将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本

• saveAsSequenceFile(path) 保存成Sequencefile文件

• 将数据集中的元素以Hadoop Sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统

• 只有kv类型RDD有该操作，单值的没有

• saveAsObjectFile(path) 序列化成对象保存到文件

• 用于将RDD中的元素序列化成对象，存储到文件中

• foreach遍历RDD中每一个元素

• def foreach(f: T => Unit): Unit

• 在Executor端执行foreach

• foreachPartition以分区为单位遍历RDD中每一个元素

• def foreachPartition(f: Iterator[T] => Unit): Unit