[ Spark ] RDD转换算子汇总

bone_ds

于 2022-06-14 00:13:56 发布

阅读量602

点赞数

分类专栏： Spark 文章标签： spark big data scala

本文链接：https://blog.csdn.net/jason_bone_/article/details/125269984

版权

Spark 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

前置知识:

为了区分RDD的方法和集合的方法

RDD方法=>RDD算子(改变问题状态的操作,在Spark中表现为:将旧的RDD转换为新的RDD)

RDD转换算子

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

Value类型

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

将数据逐条进行映射转换,值/类型的转换

//map
val mapRDD = rdd.map(
      num=>{println(">>>>>>"+num)
      num * 2}
    )

    val map1RDD = mapRDD.map(
      num => {
        println("######" + num)
        num
      }
    )

    //分区内数据是一个个执行逻辑,即前面数据全部逻辑执行完毕,才会执行下一个数据
    //分区内数据的执行是有序的
    //而分区间的数据执行是无序的
    val map1: Array[Int] = map1RDD.collect()

2)def mapPartitions[U: ClassTag](

f: Iterator[T] => Iterator[U],

preservesPartitioning: Boolean = false): RDD[U]

将待处理的数据以分区为单位发送到计算节点进行处理

val rdd = sc.makeRDD(List(1, 2, 3, 4),2)//分区数1/2

    //mapPartitions:以分区为单位,每个分区一个迭代器进行数据转换操作
    //但会将整个分区的数据加载到内存中进行引用,
    //分区内处理完的数据不会释放,存在对象的引用
    //若内存较小,数据量较大,容易出现内存溢出
    val mapRDD = rdd.mapPartitions(
      iterator=>{println(">>>>>>")
      iterator.map(_ * 2)}
    )

    val map: Array[Int] = mapRDD.collect()

问:map和mapPartitions的区别？

①数据处理角度

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

②功能的角度

Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。

MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据

③性能的角度

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

3)def mapPartitionsWithIndex[U: ClassTag](

f: (Int, Iterator[T]) => Iterator[U],

preservesPartitioning: Boolean = false): RDD[U]

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

    //功能:获取指定分区的数据
    val mapRDD = rdd.mapPartitionsWithIndex(
      (index,iterator)=> {
        if (index == 1) {
          iterator
        } else Nil.iterator
      }
    )


    val map: Array[Int] = mapRDD.collect()
//
//
val rdd = sc.makeRDD(List(1, 2, 3, 4),2)

    //功能:打印数据来自哪个分区
    val mapRDD = rdd.mapPartitionsWithIndex(
      (index,iterator)=> {
        iterator.map(num=>(index,num))
      }
    )


    val map= mapRDD.collect()

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

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

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

    //功能:扁平化
    val mapRDD = rdd.flatMap(
      data=>{
        //模式匹配
        data match {
          case list: List[_]=>list
          case i:Int=>List(i)
        }
      }
    )


    val map= mapRDD.collect()

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

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

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

    //功能:计算所有分区最大值,求和
    val mapRDD = rdd.glom().map(data=>data.max)


    val map= mapRDD.collect()
    
    println(map.sum)

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

分组, 分区默认不变，但是数据会被打乱重新组合，即Shuffle.极限情况下，数据可能被分在同一个分区中(数据倾斜),一个组的数据在一个分区中，但是并不是说一个分区中只有一个组(分区和组没有必然关系)

val rdd = sc.makeRDD(List("Hello","Scala","Spark","Hadoop"),2)

    //功能:按照单词首字母不同分组
    val mapRDD = rdd.groupBy(_.charAt(0))


    val map= mapRDD.collect()

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

将数据根据指定的规则进行(逐条)筛选过滤,当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，极限情况下，可能会出现数据倾斜。

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

    //功能:过滤
    val mapRDD = rdd.filter(_%2==0)


    val map= mapRDD.collect()

8)def sample(

withReplacement: Boolean,

fraction: Double,

seed: Long = Utils.random.nextLong): RDD[T]

从数据集中抽取数据

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

    //para1:false不放回/true放回
    //para2:每条数据被抽取的概率/每条数据可能重复的次数
    //para3:种子/时间作为种子
    val mapRDD = rdd.sample(true,4,3)


    val map= mapRDD.collect()

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

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

将数据集中重复的数据去重

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

    //功能:去重,与scala中的集合方法不同,
    //底层:map(x => (x, null)).reduceByKey((x, y) => x, numPartitions).map(_._1)
    val mapRDD = rdd.distinct()
    //不使用distinct实现去重
    rdd.map((_,1)).reduceByKey((x,y)=>x+y).map(_._1).collect().foreach(println)

    println(List(1, 2, 1, 2).distinct)//scala中利用hashset去重


    val map= mapRDD.collect()

10)def coalesce(numPartitions: Int, shuffle: Boolean = false,

partitionCoalescer: Option[PartitionCoalescer] = Option.empty)

(implicit ord: Ordering[T] = null)

: RDD[T]

缩减分区,当spark程序中，存在过多的小任务的时候，可以通过coalesce方法，收缩合并分区，减少分区的个数，减小任务调度成本

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

    //功能:缩减分区
    //默认为false不shuffle
    //true为shuffle后重组
    val mapRDD = rdd.coalesce(2,true)
    mapRDD.saveAsTextFile("datas/output")

    val map= mapRDD.collect()

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

重分区,该操作内部其实执行的是coalesce操作，参数shuffle的默认值为true。

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

    //功能:扩大分区
    val mapRDD = rdd.repartition(3)
    mapRDD.saveAsTextFile("datas/output")

    val map= mapRDD.collect()

问:coalesce和repartition区别？

repartition算子其实底层调用的就是coalesce算子，只不过固定使用了shuffle的操作,可以让数据更均衡一下，可以有效防止数据倾斜问题。

如果缩减分区，一般就采用coalesce，如果想扩大分区，就采用repartition

12)def sortBy[K](

f: (T) => K,

ascending: Boolean = true,

numPartitions: Int = this.partitions.length)

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

排序数据。默认为正序排列。不改变分区,但由于将原来的顺序打乱,所以中间存在shuffle操作

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

    //功能:排序,默认true升序,false降序,存在打乱shuffle
    val mapRDD = rdd.sortBy(_._1.toInt,false)

    val map= mapRDD.collect()

双Value类型

交集/并集/差集/拉链

val rdd1 = sc.makeRDD(List(1,2,3,4))
    val rdd2 = sc.makeRDD(List(3,4,5,6))
    val rdd7 = sc.makeRDD(List("3","4","5","6"))

    //交集,泛型类型必须一致
    rdd1.intersection(rdd2).collect().foreach(println)
    println("-------------")

    //并集,类型必须一致
    rdd1.union(rdd2).collect().foreach(println)
    println("-------------")

    //差集,类型必须一致
    rdd1.subtract(rdd2).collect().foreach(println)
    println("-------------")

    //拉链,可以类型不一致,但分区数和分区内数据量都得一致
    rdd1.zip(rdd2).collect().foreach(println)
    rdd1.zip(rdd7).collect().foreach(println)

Key-Value类型

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

将数据按照指定Partitioner重新进行分区。

说明:该函数来自PairRDDFunctions类,对RDD隐式转换然后调用

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

    val mapRDD = rdd.map((_, 1))

    //按规则将(k,v)数据重分区
//    mapRDD.partitionBy(new HashPartitioner(2)).saveAsTextFile("output")

    //如果两次分区器得类型和分区数相等,底层判断为同一分区器,不做操作
    mapRDD.partitionBy(new HashPartitioner(2)).partitionBy(new HashPartitioner(2)).saveAsTextFile("output")

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

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

将数据按照相同的Key对Value进行聚合

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

    //聚合:两两聚合,所以key的数据只有一个的不会参与运算
    val mapRDD = rdd.reduceByKey((x,y)=>{
      println(s"x=${x},y=${y}")
      x+y
    })

    mapRDD.saveAsTextFile("output")

    mapRDD.collect().foreach(println)

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

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

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

val rdd = sc.makeRDD(List(("a",1),("a",2),("a",3),("b",4)),2)    
//聚合:两两聚合,所以key的数据只有一个不会参与运算    
val mapRDD = rdd.groupByKey()    
mapRDD.collect().foreach(println)

问:reduceByKey和groupByKey的区别？(面试重点)
①从 shuffle 的角度：reduceByKey 和 groupByKey 都存在 shuffle 的操作，但是reduceByKey 可以在 shuffle 前对分区内相同 key 的数据进行预聚合（combine）功能，这样会减少落盘的数据量，而groupByKey 只是进行分组，不存在数据量减少的问题，reduceByKey 性能比较高。注意:分区内和分区间计算规则是相同的
②从功能的角度：reduceByKey 其实包含分组和聚合的功能。GroupByKey 只能分组，不能聚合，所以在分组聚合的场合下，推荐使用 reduceByKey，如果仅仅是分组而不需要聚合。那
么还是只能使用 groupByKey

4)def aggregateByKey[ U: ClassTag] (zeroValue: U)(seqOp: (U, V) => U,

combOp: (U, U) => U): RDD[(K, U)]

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

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

    //聚合:分区内取最大值,然后相加
    //初始值的作用:碰见第一个key时,和value进行分区内计算
    val mapRDD = rdd.aggregateByKey(0)((x,t)=>math.max(x,t),(x,y)=>x+y)
    
//---------------------
val rdd = sc.makeRDD(List(("a",1),("a",2),("b",3),("b",4),("b",5),("a",6)),2)

    //聚合:aggregateByKey若分区间和分区内的计算规则相同,用简化方法
    val mapRDD = rdd.foldByKey(0)(_+_)


    mapRDD.collect().foreach(println)
//----------------------
val rdd = sc.makeRDD(List(("a",1),("a",2),("b",3),("b",4),("b",5),("a",6)),2)

    //聚合:求平均值
    val mapRDD: RDD[(String, (Int, Int))] = rdd.aggregateByKey((0, 0))((t, v) 
    => (t._1 + v, t._2 + 1), (x, y) => (x._1 + y._1, y._2 + y._2))

    //mapvalues只转换value
//    mapRDD.mapValues{case(x,y)=>{x/y}}.collect().foreach(println)
    mapRDD.map{x=>(x._1,x._2._1/x._2._2)}.collect().foreach(println)

5)def combineByKey[C](

createCombiner: V => C,

mergeValue: (C, V) => C,

mergeCombiners: (C, C) => C): RDD[(K, C)]

最通用的对key-value型rdd进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。注意:必须声明后两个参数函数中的与初始值类型相同的参数类型,不可简化

val rdd = sc.makeRDD(List(("a",1),("a",2),("b",3),("b",4),("b",5),("a",6)),2)

//聚合:求平均值,这里的对偶元组必须指明类型
val mapRDD= rdd.combineByKey((_,1),(t:(Int,Int), v) => (t._1 + v, t._2 + 1), (x:(Int,Int), y:(Int,Int)) 
=> (x._1 + y._1, y._2 + y._2))


mapRDD.map{x=>(x._1,x._2._1/x._2._2)}.collect().foreach(println)

问:reduceByKey、foldByKey、aggregateByKey、combineByKey的区别？
从源码的角度来讲，四个算子的底层逻辑是相同的combineByKey。
aggregateByKey的算子会将初始值和第一个value使用分区内的计算规则进行计算
foldByKey的算子的分区内和分区间的计算规则相同，并且初始值和第一个value使用的规则相同
combineByKey第一个参数就是对第一个value进行处理，所以无需初始值。
reduceByKey不会对第一个value进行处理，分区内和分区间计算规则相同
上面的四个算子都支持预聚合功能。所以shuffle性能比较高
上面的四个算子都可以实现WordCount

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

相同key对应的所有元素连接在一起

val rdd1 = sc.makeRDD(List(("a",1),("b",2),("c",3)),2)
val rdd2 = sc.makeRDD(List(("a",4),("b",5),("c",6),("a",3)),2)

//join与zip不同,不是按索引的,而是按key相同来筛选,将value合为元组,没join上的不会出现在结果中
//key有多个相同的会依次匹配会出现笛卡尔积,数据量倍增
val joinRDD = rdd1.join(rdd2)

joinRDD.collect().foreach(println)

7)def leftOuterJoin[W] (other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]

左外连接

val rdd1 = sc.makeRDD(List(("a",1),("b",2),("c",3)),2)
val rdd2 = sc.makeRDD(List(("a",4),("b",5)),2)

//左连接时右表的元素类型变为可选类型,Option类,右连接同理
val joinRDD = rdd1.leftOuterJoin(rdd2)

joinRDD.collect().foreach(println)

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

val rdd1 = sc.makeRDD(List(("a",1),("b",2),("c",3)),2)
val rdd2 = sc.makeRDD(List(("a",4),("b",5),("c",6),("c",7)),2)

//cogroup:connect+group,两边的相同key的value先组成迭代器,两边的迭代器组成元组后,在外层又与key组成元组
val joinRDD = rdd1.cogroup(rdd2)

joinRDD.collect().foreach(println)

bone_ds

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[ Spark ] RDD转换算子汇总

前置知识:为了区分RDD的方法和集合的方法RDD方法=>RDD算子(改变问题状态的操作,在Spark中表现为:将旧的RDD转换为新的RDD)RDD整体上分为Value类型、双Value类型和Key-Value类型1)def map[ U: ClassTag ] (f: T => U): RDD[U] 将数据逐条进行映射转换,值/类型的转换2)def mapPartitions[U: ClassTag]( f: Iterator[T] => Iterator[U], preservesPartitio
复制链接

扫一扫