Spark 之 RDD转换算子

---

前言

本文介绍Spark三大数据结构之一的RDD的转换算子，通过配合案例使读者更加深刻的了解各大转换算子的作用及其使用方法；

---

Spark 知识系列文章

   此处罗列了有关Spark相关知识的其他文章，有需要的可以进行点击查阅。

   Spark 之 Spark框架及部署

   Spark 之Spark三大数据结构

   Spark 之 RDD行动算子

   Spark 之 SparkSQL

   Spark 之 SparkStreaming

一、RDD的转换算子

RDD整体上分为Value类型和Key-Value类型

1.1 Value类型

1.1.1 map(func)案例

作用：每次处理一条数据，返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成

需求：创建一个1-10数组的RDD，将所有元素*2形成新的RDD

实现：

1.1.2 mapPartitions(func) 案例

作用：类似于map，但独立地在RDD的每一个分片（分区）上运行。假设有N个元素，有M个分区，那么map的函数的将被调用N次,而mapPartitions被调用M次,一个函数一次处理所有分区。

需求：创建一个RDD，使每个元素*2组成新的RDD

实现：

mapPartition()：每次处理一个分区的数据，这个分区的数据处理完后，原RDD中分区的数据才能释放，可能导致OOM。比如处理p0分区的数据，该分区数据有10G，但是Executor内存只有2G，就会出现OOM；

1.1.3 Map 和 MapPartition的区别

需求：将hello映射成Xhello；

Map在进行映射的时候是一条一条执行，有N个单词就会执行N次Map;

MapPartition是按照分区处理的，一次处理一个分区，如果N个单词分为M个分区，MapPartition只需要执行M次；

1.1.4 flatMap(func) 案例

作用：类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）

需求：将列表中的元素一个个取出来

实现：

1.1.5 glom案例

作用：将每一个分区形成一个数组，形成新的RDD类型是RDD[Array[T]]

使用环境：比如要求每一个分区里面的最值，用glom算子就很方便。

需求：创建一个4个分区的RDD，并将每个分区的数据放到一个数组

实现：

1.1.6 groupBy(func)案例

作用：分组，按照传入函数的返回值进行分组。将相同的key对应的值放入一个迭代器。

需求：创建一个RDD，按照元素模以2的值进行分组。

实现：

1.1.7 sample(withReplacement, fraction, seed) 案例

作用：以指定的随机种子随机抽样出数量为fraction的数据，withReplacement表示抽出的数据是否放回，true为有放回的抽样，false为无放回的抽样，seed用于指定随机数生成器种子。

需求：创建一个RDD（1-10），从中选择放回和不放回抽样

实现：

1.1.8 distinct([numTasks])) 案例

作用：对源RDD进行去重后返回一个新的RDD。默认情况下，只有8个并行任务来操作，但是可以传入一个可选的numTasks参数改变它。

注意：经过distinct去重，数据会出现乱序，重组现象（内部进行了Shuffle）。

需求：创建一个RDD，使用distinct()对其去重。

实现：

1.1.9 coalesce(numPartitions) 案例

作用：缩减分区数，用于大数据集过滤后，提高小数据集的执行效率。

需求：创建一个4个分区的RDD，对其缩减分区

实现：

1.1.10 repartition(numPartitions) 案例

作用：根据分区数，重新通过网络随机洗牌所有数据。并不是简单的合并分区，而是要将数据均匀的分配到最终分区，避免数据倾斜。

需求：创建一个4个分区的RDD，对其重新分区

实现：val rerdd = listRDD.repartition(2);
代码同2.1.9 中的雷同，将coalesce语句修改为repartition即可；

1.1.11 coalesce和repartition的区别

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

repartition实际上是调用的coalesce，默认是进行shuffle的。

1.1.12 sortBy(func,[ascending], [numTasks]) 案例

作用；使用func先对数据进行处理，按照处理后的数据排序，默认为正序。Ascending 参数决定排序顺序（false – 降序）；

需求：创建一个RDD，按照不同的规则进行排序

实现：rdd.sortBy(x=>x).collect()

1.2 双Value类型操作

1.2.1 union(otherDataset) 案例

作用：对源RDD和参数RDD求并集后返回一个新的RDD

需求：创建两个RDD，求并集

实现：val rdd3 = rdd1.union(rdd2)

1.2.2 subtract (otherDataset) 案例

作用：计算差的一种函数，去除两个RDD中相同元素，不同的RDD将保留下来

需求：创建两个RDD，求第一个RDD与第二个RDD的差集

实现：rdd1.subtract (rdd2)

1.2.3 intersection(otherDataset) 案例

作用：对源RDD和参数RDD求交集后返回一个新的RDD

需求：创建两个RDD，求两个RDD的交集

实现：val rdd3 = rdd1.intersection(rdd2)

1.2.4 cartesian(otherDataset) 案例

作用：笛卡尔积（尽量避免使用）

需求：创建两个RDD，计算两个RDD的笛卡尔积

实现：rdd1.cartesian(rdd2)

1.2.5 zip(otherDataset)案例

作用：将两个RDD组合成Key/Value形式的RDD,这里默认两个RDD的partition数量以及元素数量都相同，否则会抛出异常。

需求：创建两个RDD，并将两个RDD组合到一起形成一个(k,v)RDD

实现：rdd1.zip(rdd2)

1.3 Key-Value类型

1.3.1 partitionBy案例

作用：对pairRDD进行分区操作，如果原有的partionRDD和现有的partionRDD是一致的话就不进行分区， 否则会生成ShuffleRDD，即会产生shuffle过程。

需求：创建一个4个分区的RDD，对其重新分区

实现：var rdd2 = rdd.partitionBy(new org.apache.spark.HashPartitioner(2))

1.3.2 groupByKey案例

作用：groupByKey也是对每个key进行操作，但只生成一个sequence。

需求：创建一个pairRDD，将相同key对应值聚合到一个sequence中，并计算相同key对应值的相加结果。

实现：
var rdd2 = rdd.groupByKey()
rdd2.map(t => ( t._1 , t._2.sum))

1.3.3 reduceByKey(func, [numTasks]) 案例

作用：在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置。

需求：创建一个pairRDD，计算相同key对应值的相加结果

实现：var rdd2 = rdd.reduceByKey((x,y)=> x+y )

1.3.4 reduceByKey和groupByKey的区别

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

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

1.3.5 aggregateByKey案例

参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

作用：在kv对的RDD中，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数（比如求最大值）的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。

参数描述：
（1）zeroValue：给每一个分区中的每一个key一个初始值；因为Scala中的计算规则都是两两计算；

（2）seqOp：函数用于在每一个分区中用初始值逐步迭代value；(比如求最大值)

（3）combOp：函数用于合并每个分区中的结果。（分区间的计算）

需求：创建一个pairRDD，取出每个分区相同key对应值的最大值，然后相加

实现：

注意：初始值只有在第一次拿到一个数据的时候会有用，因为取最大值的时候，如果第一次取到一个数据他不知道和谁比所以需要初始值来辅助比较。

实现流程：

1.3.6 foldByKey案例

参数：(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

作用：aggregateByKey的简化操作，seqop和combop相同，即分区内和分区间实现的的功能一样

需求：创建一个pairRDD，计算相同key对应值的相加结果

实现：var rdd2 = rdd.foldByKey(0)(+)

1.3.7 combineByKey[C] 案例

参数：(createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C)
     (初始值             分区内                分区间)

作用：对相同K，把V合并成一个集合。

参数描述：
（1）createCombiner: combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素,combineByKey()会使用一个叫作createCombiner()的函数来创建那个键对应的累加器的初始值

（2）mergeValue: 如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并

（3）mergeCombiners: 由于每个分区都是独立处理的， 因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器， 就需要使用用户提供的 mergeCombiners() 方法将各个分区的结果进行合并。

需求：创建一个pairRDD，根据key计算每种key的均值。（先计算每个key出现的次数以及对应值的总和，再相除得到结果）

实现：

语句解释：比如初始值为20，该条语句实现初始值由 20 -> (20,1) , 由变化后的初始值 和 后续的值比如30 进行计算->(50,2)

计算平均值：

实现流程：

1.3.8 sortByKey([ascending], [numTasks]) 案例

作用：在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD。而Sortby是自己指定排序规则。

需求：创建一个pairRDD，按照key的正序（true）和倒序（false）进行排序

实现：rdd.sortByKey(true)

1.3.9 mapValues案例

作用：针对于(K,V)形式的类型只对V进行操作

需求：创建一个pairRDD，并将value添加字符串"|||"

实现：rdd.mapValues(_+|||)

1.3.10 join(otherDataset, [numTasks]) 案例

作用：在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD

需求：创建两个pairRDD，并将key相同的数据聚合到一个元组。

实现：rdd.join(rdd1)

1.3.11 cogroup(otherDataset, [numTasks]) 案例

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

需求：创建两个pairRDD，并将key相同的数据聚合到一个迭代器。

实现：

---

总结

本文介绍Spark三大数据结构之一的RDD的转换算子，通过配合案例使读者更加深刻的了解各大转换算子的作用及其使用方法；如果有不足之处或者表述不当的地方欢迎大家指正。