Spark核心编程系列(二)——RDD转换算子

最新推荐文章于 2022-11-25 16:38:52 发布

Stray_Lambs

最新推荐文章于 2022-11-25 16:38:52 发布

阅读量790

点赞数

分类专栏： Spark 大数据文章标签：大数据 spark

本文链接：https://blog.csdn.net/Stray_Lambs/article/details/117528254

版权

大数据同时被 2 个专栏收录

37 篇文章 2 订阅

订阅专栏

Spark

13 篇文章 1 订阅

订阅专栏

RDD算子介绍

Spark算子大致可以分为两类：

Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。
Action 行动算子：这类算子会触发 SparkContext 提交 Job 作业。

Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。而Action 算子会触发 Spark 提交作业（Job），并将数据输出 Spark系统。

RDD转换算子

RDD根据数据处理方式的不同将算子整体上分为Value类型、双Value类型和Key-Value类型。

Value类型

1）map

函数签名

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

将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。

val sparkConf = new SparkConf().setAppName().setMaster("local[*]")
val sc = new SparkContext(sparkConf)

val rdd = sc.makeRDD(List(1,2,3,4))

def mapFunction(number : Int): Int = {
    number * 2
}

val mapRDD:RDD[Int] = rdd.map(mapFunction)

val mapRDD1:RDD[Int] = rdd.map(_*2)

sc.stop()

注意：

1、rdd的计算一个分区内的数据是一个一个执行逻辑，只有前面一个数据全部执行完毕后，才会执行下一个数据。分区内数据的执行是有序的。

2、不同分区数据计算是无序的。

小功能：可以从服务器日志数据apache.log中获取用户请求URL资源路径。

2）mapPartitions

函数签名

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

将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。

mapPartitions：可以以分区为单位进行数据转换操作，但是会将整个分区的数据加载到内存进行引用。如果处理完的数据是不会被释放掉，因为存在对象的引用。在内存较小，数据量较大的场景下，容易出现内存溢出现象。

map和mapPartition的区别：

1、数据处理角度：

Map算子是分区内一个数据一个数据的执行，类似于串行操作。而mapPartitions算子是以分区为单位进行批处理操作。

2、功能的角度：

Map算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据。

3、性能的角度：

Map算子因为类似于串行操作，所以性能比较低，而是mapPartitions算子类似于批处理，所以性能较高。但是mapPartitions算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。推荐使用map操作。

完成比完美更重要。

3）mapPartitionsWithIndex

函数签名

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

函数说明

将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。

4) flatMap

函数签名

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

函数说明

将处理的数据进行扁平化后在进行映射处理，所以算子也称之为扁平映射

5）glom

函数签名

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

函数说明

将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变。

6）groupBy

函数签名

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

函数说明

将数据根据指定的规则进行分组，分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中。

一个组的数据在一个分区中，但是并不是说一个分区中只有一个组。即分组和分区没有必然的关系。

7）filter

函数签名

def filter(f:T=>Boolean):RDD[T]

函数说明

将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。

8）sample

函数签名

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

函数说明

根据指定的规则从数据集中抽取数据。sample算子需要传递三个参数。

第一个参数表示，抽取数据后是否将数据放回 true放回（泊松算法），false不放回（伯努利算法）；

第二个参数表示，

如果是不放回场景，表示数据源中每条数据被抽取的概率，基准值的概念；

如果是放回场景，表示数据源中每条数据被抽取的可能次数。

第三个参数表示，抽取数据时随机算法的种子，如果不传递第三个参数，则使用当前系统时间为随机算法的种子。

9）distinct

函数签名

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

函数说明

将数据集中的重复数据去重，底层采用的是

来进行去重的。

10）coalesce

函数签名

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

函数说明

根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率。当spark程序中，存在过多的小任务的时候，可以通过coalesce方法，收缩合并分区，减少分区的个数，减小任务调度成本。

coalesce方法默认情况下不会将分区的数据打乱重新组合，所以这种情况下的缩减分区可能会导致数据不均衡，出现数据倾斜。如果想要让数据均衡，则可以进行shuffle处理，即第二个参数传入为true。

coalesce算子可以扩大分区的数量，但是必须要进行shuffle操作，否则不起作用。不过一般扩大分区使用的是repartition函数，这个函数底层就是coalesce函数，只不过固定了shuffle为true。

11）sortBy

函数签名

def sortBy[K](

    f: (T) => K,

    ascending: Boolean = true,

    numPartitions: Int = this.partitions.size)

    (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T] =

  this.keyBy[K](f)

      .sortByKey(ascending, numPartitions)

      .values

函数说明

sortBy方法可以根据指定的规则对数据源中的数据进行排序，默认为升序，第二个参数可以改为降序(false)，sortBy默认情况下，不会改变分区，但是中间存在着shuffle的操作。

双value类型

12）intersection、union、subtract

函数签名

def intersection(other:RDD[T]):RDD[T]
def union(other:RDD[T]):RDD[T]
def subtract(other:RDD[T]):RDD[T]

函数说明

对源RDD和参数RDD求交集、并集、差集后返回一个新的RDD。并且，要求两个数据源的数据类型需要保持一致。

13）zip

函数签名

函数说明

将两个数据源数据一一匹配在一起，两个数据源可以不同类型，但是要求分区数量一致以及分区元素的数量相同。

Key-Value类型

14）partitionBy

函数签名

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

函数说明

将数据按照指定Partitioner重新进行分区。其中，调用的并不是RDD的类，而是其他类(pairRDDFunctions)。

使用了Scala当中的隐式转换(可以理解为二次编译)，Spark默认的分区器是HashPartitioner，底层源码是

若重分区的分区器和当前的RDD的分区器一样，那么将不会做任何处理，底层源码进行了特殊的判断。并且Spark还有其他的分区器，例如HashPartitioner、RangerPartitioner、PythonPartitioner(这个是特定的包内才可以运行)，也可以自定义分区的规则。

15）reduceByKey

函数签名

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

函数说明

可以将数据按照相同的Key对Value进行聚合。reduceByKey相同的Key的数据进行Value数据的聚合操作，基于两两聚合。如果key的数据只有一个，那么，是不会参与运算的。

16）groupByKey

函数签名

def groupByKey():RDD[(K,Iterable[V])]
def groupByKey(numPartitions:Int):RDD[(K,Iterable[V])]
def groupByKey(partitioner:Partitioner):RDD[(K,Iterable[V])]

函数说明

将分区的数据直接转换为相同类型的内存数组进行后续处理。将数据源中的数据，相同key的数据分在一个组中，形成一个对偶元组。元组中的第一个元素就是key，元组中的第二个元素就是相同key的value的集合。

grouByKey函数与groupBy函数的区别：1、groupBy不确定是以哪一个维度进行分组的，而groupByKey固定是以Key来进行分组的；2、value的表达形式是不同的，groupByKey直接是value的集合，而groupByKey则是一个元组的集合形式，如图所示。

groupByKey函数与reduceByKey函数的区别：首先，spark中，shuffle操作必须要求落盘处理，不能在内存中数据等待，会导致内存溢出。shuffle操作性能非常低。

其次，reduceByKey支持分区内预聚合功能，可以有效减少shuffle时落盘的数据量，提升shuffle的性能。

总结：

1、从shuffle的角度：reduceByKey和groupByKey都存在shuffle的操作，但是reduceByKey可以在shuffle前对分区内相同key的数据进行预聚合(combine)功能，这样会减少落盘的数据量，而groupByKey只是进行分组，不存在数据量减少问题，reduceByKey性能更高。

2、从功能的角度：reduceByKey其实包含分组和聚合的功能。groupByKey只能分组，不能聚合，所以需要视情况而定，具体使用哪个函数。

17) aggregateByKey

函数签名

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

函数说明

将数据根据不同的规则进行分区内计算和分区间计算，最终返回的数据结果应该和初始值的类型保持一致。

aggregateByKey存在函数柯里化(柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。)，有两个参数列表

第一个参数列表，需要传递一个参数，表示为初始值

主要用于当碰见第一个key的时候，和value进行分区内计算

第二个参数列表需要传递两个参数

第一个参数表示分区内计算规则

第二个参数表示分区间计算规则

当分区内与分区间的计算相同时，可以使用简化版本，foldByKey函数来实现功能。

18） combineByKey

函数签名

def combineByKey[C](  

createCombiner: V => C,  

mergeValue: (C, V) => C,  

mergeCombiners: (C, C) => C

)

函数说明

combineByKey方法需要三个参数。

第一个参数表示：将相同的key的第一个数据进行结构转换，实现操作

第二个参数表示：分区内的计算规则

第三个参数表示：分区间的计算规则

聚合函数小结：

这四种函数调用的底层函数都是一样的，只不过是参数的不同。

19）join

函数签名

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

函数说明

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

如果两个数据源中的key没有匹配上，那么数据不会出现在结果中。

如果两个数据源中key有多个相同的，会依次匹配，可能会出现笛卡尔积，数据量会几何性增长，会导致性能降低。

还有leftOuterJoin、rightOuterJoin函数与SQL类似，这里就不多介绍了。

20）cogroup

函数签名

/**
   * For each key k in `this` or `other`, return a resulting RDD that contains a tuple with the
   * list of values for that key in `this` as well as `other`.
   */
  def cogroup[W](other: JavaPairRDD[K, W], partitioner: Partitioner)
  : JavaPairRDD[K, (JIterable[V], JIterable[W])] =
    fromRDD(cogroupResultToJava(rdd.cogroup(other, partitioner)))

函数说明

可以理解为分组+连接的操作。

（PS：这么多算子，感觉需要多用才能记得牢）