Spark RDD算子详解

数据求学家

已于 2022-05-10 08:22:54 修改

阅读量3.3k

点赞数 1

分类专栏： spark 大数据开发文章标签： big data spark 大数据 scala

于 2022-02-07 21:21:44 首次发布

本文链接：https://blog.csdn.net/weixin_36040866/article/details/122810519

版权

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

8 篇文章 0 订阅

订阅专栏

spark

6 篇文章 0 订阅

订阅专栏

RDD方法=>RDD算子(Operator 操作)

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

转换算子（Transformation）：功能的补充和封装，将旧的RDD包装成新的RDD（flatMap,map...)
行动算子（Action）：触发任务的调度和作业的执行(collect,foreach..)

附：

Spark其他数据结构介绍可移步至：Spark数据结构（累加器+广播变量）
SparkSQL项目实操可移步至：Sparksql项目实操

一、转换算子

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

1.Value类型

1）map

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

val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
val rdd = sc.makeRDD(List(1,2,3,4))
        // 1,2,3,4
        // 2,4,6,8

        // 转换函数
def mapFunction(num:Int): Int = {
            num * 2
        }
        //回顾Scala至简原则
        //val mapRDD: RDD[Int] = rdd.map(mapFunction)
        //val mapRDD: RDD[Int] = rdd.map((num:Int)=>{num*2})
        //val mapRDD: RDD[Int] = rdd.map((num:Int)=>num*2)
        //val mapRDD: RDD[Int] = rdd.map((num)=>num*2)
        //val mapRDD: RDD[Int] = rdd.map(num=>num*2)
val mapRDD: RDD[Int] = rdd.map(_*2)
mapRDD.collect().foreach(println)

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

2）mapPartitions

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

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

eg:获取每个数据分区的最大值

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

// 【1，2】，【3，4】
// 【2】，【4】
val mpRDD = rdd.mapPartitions(
     iter => {
        List(iter.max).iterator
              }
        )

map和mapPartitions区别：

数据处理角度。Map算子是分区内一个数据一个数据的执行，类似于串行操作。而mapPartitions算子是以分区为单位进行批处理操作。
功能的角度。Map算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据
性能的角度。Map算子因为类似于串行操作，所以性能比较低，而是mapPartitions算子类似于批处理，所以性能较高。但是mapPartitions算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用map操作。

3）mapPartitionsWithIndex

def mapPartitionsWithIndex[U: ClassTag](

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

preservesPartitioning: Boolean = false): RDD[U]

eg:获取第二个数据分区的数据

val rdd = sc.makeRDD(List(1,2,3,4), 2)
// 【1，2】，【3，4】
val mpiRDD = rdd.mapPartitionsWithIndex(
    (index, iter) => {
          if ( index == 1) {
                iter
                   } else {
                Nil.iterator
                   }
            }

eg.获取每个数据的分区

val mpiRDD = rdd.mapPartitionsWithIndex(
   (index, iter) => {
    // 1,   2,    3,   4
    //(0,1)(2,2),(4,3),(6,4)
         iter.map(
             num => {
                  (index, num)
                    }
                )
            }
        )

4）flatMap

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

将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射，与map相比就是多了扁平化操作

eg.将List(List(1,2),3,List(4,5))进行扁平化操作

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

val flatRDD = rdd.flatMap(
    data => {
    //模式匹配
          data match {
              case list:List[_] => list
              case dat => List(dat)
                }
            }
        )

5）glom

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

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

eg:计算所有分区最大值求和（分区内取最大值，分区间最大值求和）

val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4), 2)

// 【1，2】，【3，4】
// 【2】，【4】
// 【6】
val glomRDD: RDD[Array[Int]] = rdd.glom()

val maxRDD: RDD[Int] = glomRDD.map(
     array => {
          array.max
            }
        )
println(maxRDD.collect().sum)

6）groupBy

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

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

eg.将List("Hello", "hive", "hbase", "Hadoop")根据单词首写字母进行分组。

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

// 分组和分区没有必然的关系
// groupBy会将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组
// 相同的key值的数据会放置在一个组中
val groupRDD = rdd.groupBy(_.charAt(0))
//(H,CompactBuffer(Hello, Hadoop));(S,CompactBuffer(Spark, Scala))

7）filter

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

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

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

val filterRDD: RDD[Int] = rdd.filter(num=>num%2!=0)
//1
//3

8）sample（子集）

def sample( withReplacement: Boolean,

fraction: Double,

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

// sample算子需要传递三个参数
// 1. 第一个参数表示，抽取数据后是否将数据返回 true（放回），false（丢弃）
// 2. 第二个参数表示，
//         如果抽取不放回的场合：数据源中每条数据被抽取的概率，基准值的概念(相当于阈值）
//         如果抽取放回的场合：表示数据源中的每条数据被抽取的可能次数
// 3. 第三个参数表示，抽取数据时随机算法的种子
//                    如果不传递第三个参数，那么使用的是当前系统时间
println(rdd.sample(
    false,
    0.4
    1
).collect().mkString(","))

9）distinct （去重）

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))

val rdd1: RDD[Int] = rdd.distinct()

rdd1.collect().foreach(println)
//4;1;2;3

10）coalesce(缩减分区）

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)

        // coalesce方法默认情况下不会将分区的数据打乱重新组合
        // 这种情况下的缩减分区可能会导致数据不均衡，出现数据倾斜
        // 如果想要让数据均衡，可以进行shuffle处理
        //val newRDD: RDD[Int] = rdd.coalesce(2)
val newRDD: RDD[Int] = rdd.coalesce(2,true)
newRDD.saveAsTextFile("output")

11）repartition (扩大分区，其实只记coalesce即可)

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

该操作内部其实执行的是coalesce操作，参数shuffle的默认值为true。无论是将分区数多的RDD转换为分区数少的RDD，还是将分区数少的RDD转换为分区数多的RDD，repartition操作都可以完成，因为无论如何都会经shuffle过程。

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

// coalesce算子可以扩大分区的，但是如果不进行shuffle操作，是没有意义，不起作用。
// 所以如果想要实现扩大分区的效果，需要使用shuffle操作
// spark提供了一个简化的操作
// 缩减分区：coalesce，如果想要数据均衡，可以采用shuffle
// 扩大分区：repartition, 底层代码调用的就是coalesce，而且肯定采用shuffle
//val newRDD: RDD[Int] = rdd.coalesce(3, true)
val newRDD: RDD[Int] = rdd.repartition(3)

12）sortBy（排序）

def sortBy[K]( f: (T) => K,

ascending: Boolean = true,

numPartitions: Int = this.partitions.length)

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

在排序之前，可以将数据通过f函数进行处理，之后按照f函数处理的结果进行排序，默认为升序排列。排序后新产生的RDD的分区数与原RDD的分区数一致。中间存在shuffle的过程

val rdd = sc.makeRDD(List(6,2,4,5,3,1), 2)
val newRDD: RDD[Int] = rdd.sortBy(num=>num)


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

// sortBy方法可以根据指定的规则对数据源中的数据进行排序，默认为升序，第二个参数可以改变排序的方式
// sortBy默认情况下，不会改变分区。但是中间存在shuffle操作
val newRDD = rdd.sortBy(t=>t._1.toInt, false)

newRDD.collect().foreach(println)
//（11，2）;(2,3);(1,1)

2.双Value类型

13）intersection;union;subtract;zip(交集；并集；差集；拉链）

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

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

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

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

// 交集，并集和差集要求两个数据源数据类型保持一致
// 拉链操作两个数据源的类型可以不一致

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"))

// 交集 : 【3，4】
val rdd3: RDD[Int] = rdd1.intersection(rdd2)
//val rdd8 = rdd1.intersection(rdd7)
println(rdd3.collect().mkString(","))

// 并集 : 【1，2，3，4，3，4，5，6】
val rdd4: RDD[Int] = rdd1.union(rdd2)
println(rdd4.collect().mkString(","))

// 差集 : 【1，2】
val rdd5: RDD[Int] = rdd1.subtract(rdd2)
println(rdd5.collect().mkString(","))

// 拉链 : 【1-3，2-4，3-5，4-6】
// 两个数据源要求分区数量要保持一致和分区中的数据量保持一致
val rdd6: RDD[(Int, Int)] = rdd1.zip(rdd2)
val rdd8 = rdd1.zip(rdd7)
println(rdd6.collect().mkString(","))
//(1,3),(2,4),(3,5),(4,6)

3.Key - Value类型

14）partitionBy

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

将数据按照指定Partitioner重新进行分区。Spark默认的分区器是HashPartitioner

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

val mapRDD:RDD[(Int, Int)] = rdd.map((_,1))
// 隐式转换（二次编译）

// partitionBy根据指定的分区规则对数据进行重分区(取余分区)
val newRDD = mapRDD.partitionBy(new HashPartitioner(2))
newRDD.partitionBy(new HashPartitioner(2))

newRDD.saveAsTextFile("output")
//(1,1),(3,1);(2,1),(4,1)

15）reduceByKey（相同的key的数据进行value数据的聚合操作）

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

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

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

// reduceByKey : 相同的key的数据进行value数据的聚合操作
// scala语言中一般的聚合操作都是两两聚合，spark基于scala开发的，所以它的聚合也是两两聚合
// 【1，2，3】
// 【3，3】
// 【6】
// reduceByKey中如果key的数据只有一个，是不会参与运算的。
val reduceRDD: RDD[(String, Int)] = rdd.reduceByKey( (x:Int, y:Int) => {
  println(s"x = ${x}, y = ${y}")
   x + y    
  } )

//(a,6);(b,4)

16）groupByKey

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)
))

// groupByKey : 将数据源中的数据，相同key的数据分在一个组中，形成一个对偶元组
//              元组中的第一个元素就是key，
//              元组中的第二个元素就是相同key的value的集合
val groupRDD: RDD[(String, Iterable[Int])] = rdd.groupByKey()

groupRDD.collect().foreach(println)
//(a,(1,2,3));(b,(4))    
//(a,CompactBuffer(1, 2, 3))
//(b,CompactBuffer(4))

val groupRDD1: RDD[(String, Iterable[(String, Int)])] = rdd.groupBy(_._1)

groupRDD1.collect().foreach(println)
//(a,CompactBuffer((a,1), (a,2), (a,3)))
//(b,CompactBuffer((b,4)))

reduceByKey和groupByKey的区别

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

17）aggregateByKey（聚合）

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

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

将数据根据不同的规则进行分区内计算和分区间计算

eg.取出每个分区内相同key的最大值然后分区间相加

val rdd = sc.makeRDD(List(
     ("a", 1), ("a", 2), ("a", 3), ("a", 4)
),2)
// (a,【1,2】), (a, 【3，4】)      分区内
// (a, 2), (a, 4)                 分区间
// (a, 6)

// aggregateByKey存在函数柯里化，有两个参数列表
// 第一个参数列表,需要传递一个参数，表示为初始值
//       主要用于当碰见第一个key的时候，和value进行分区内计算
// 第二个参数列表需要传递2个参数
//      第一个参数表示分区内计算规则
//      第二个参数表示分区间计算规则

// math.min(x, y)
// math.max(x, y)
rdd.aggregateByKey(0)(
        (x, y) => math.max(x, y),
        (x, y) => x + y
    ).collect.foreach(println)
//(a,6)

eg.计算不同分区中相同key的平均值

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

// aggregateByKey最终的返回数据结果应该和初始值的类型保持一致
//val aggRDD: RDD[(String, String)] = rdd.aggregateByKey("")(_ + _, _ + _)
//aggRDD.collect.foreach(println)

// 获取相同key的数据的平均值 => (a, 3),(b, 4)
val newRDD : RDD[(String, (Int, Int))] = rdd.aggregateByKey((0,0))(
// t._1是相加的value值,t._2是该值出现的次数,v是tuple中的value
//分区内运算
    ( t, v ) => {
         (t._1 + v, t._2 + 1)
},
//分区间相加
     (t1, t2) => {
         (t1._1 + t2._1, t1._2 + t2._2)
            }
     )

val resultRDD: RDD[(String, Int)] = newRDD.mapValues {
     case (num, cnt) => {
           num / cnt
          }
     }
resultRDD.collect().foreach(println)
//(b,4);(a,3)

17）foldByKey（聚合）

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

当分区内计算规则和分区间计算规则相同时，aggregateByKey就可以简化为foldByKey

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

//rdd.aggregateByKey(0)(_+_, _+_).collect.foreach(println)

// 如果聚合计算时，分区内和分区间计算规则相同，spark提供了简化的方法
// 其实也类似于reduceByKey
rdd.foldByKey(0)(_+_).collect.foreach(println)
//(b,12);(a,9);

18）combineByKey（聚合）

def combineByKey[C]( createCombiner: V => C,

mergeValue: (C, V) => C,

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

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

// combineByKey : 方法需要三个参数
// 第一个参数表示：将相同key的第一个数据进行结构的转换，实现操作
// 第二个参数表示：分区内的计算规则
// 第三个参数表示：分区间的计算规则
val newRDD : RDD[(String, (Int, Int))] = rdd.combineByKey(
    v => (v, 1),
    ( t:(Int, Int), v ) => {
       (t._1 + v, t._2 + 1)
    },
    (t1:(Int, Int), t2:(Int, Int)) => {
       (t1._1 + t2._1, t1._2 + t2._2)
     }
    )
val resultRDD: RDD[(String, Int)] = newRDD.mapValues {
     case (num, cnt) => {
         num / cnt
     }
}
resultRDD.collect().foreach(println)

reduceByKey、foldByKey、aggregateByKey、combineByKey区别

reduceByKey: 相同key的第一个数据不进行任何计算，分区内和分区间计算规则相同

FoldByKey: 相同key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同

AggregateByKey：相同key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同

CombineByKey:当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。

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

/*
        reduceByKey:

             combineByKeyWithClassTag[V](
                 (v: V) => v, // 第一个值不会参与计算
                 func, // 分区内计算规则
                 func, // 分区间计算规则
                 )

        aggregateByKey :

            combineByKeyWithClassTag[U](
                (v: V) => cleanedSeqOp(createZero(), v), // 初始值和第一个key的value值进行的分区内数据操作
                cleanedSeqOp, // 分区内计算规则
                combOp,       // 分区间计算规则
                )

        foldByKey:

            combineByKeyWithClassTag[V](
                (v: V) => cleanedFunc(createZero(), v), // 初始值和第一个key的value值进行的分区内数据操作
                cleanedFunc,  // 分区内计算规则
                cleanedFunc,  // 分区间计算规则
                )

        combineByKey :

            combineByKeyWithClassTag(
                createCombiner,  // 相同key的第一条数据进行的处理函数
                mergeValue,      // 表示分区内数据的处理函数
                mergeCombiners,  // 表示分区间数据的处理函数
                )

*/


rdd.reduceByKey(_+_) // wordcount
rdd.aggregateByKey(0)(_+_, _+_) // wordcount
rdd.foldByKey(0)(_+_) // wordcount
rdd.combineByKey(v=>v,(x:Int,y)=>x+y,(x:Int,y:Int)=>x+y) // wordcount

19）join

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

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

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

val rdd2 = sc.makeRDD(List(
    ("a", 5), ("c", 6),("a", 4)
    ))

// join : 两个不同数据源的数据，相同的key的value会连接在一起，形成元组
//        如果两个数据源中key没有匹配上，那么数据不会出现在结果中
//        如果两个数据源中key有多个相同的，会依次匹配，可能会出现笛卡尔乘积，数据量会几何性增长，会导致性能降低。
val joinRDD: RDD[(String, (Int, Int))] = rdd1.join(rdd2)

joinRDD.collect().foreach(println)
/*
(a,(1,5))
(a,(1,4))
(a,(2,5))
(a,(2,4))
(c,(3,6))
*/

19）leftOuterJoin(RightOuterJoin)

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

均类似于sql的左/右外连接，数据结果取决于主表位置

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

val rdd2 = sc.makeRDD(List(
   ("a", 4), ("b", 5),("c", 6)
))
//val leftJoinRDD = rdd1.leftOuterJoin(rdd2)
val rightJoinRDD = rdd1.rightOuterJoin(rdd2)

//leftJoinRDD.collect().foreach(println)
rightJoinRDD.collect().foreach(println)
/*
(a,(Some(1),4))
(b,(Some(2),5))
(c,(None,6))
*/

20）cogroup

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

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

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

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

// cogroup : connect + group (分组，连接)
val cgRDD: RDD[(String, (Iterable[Int], Iterable[Int]))] = rdd1.cogroup(rdd2)

cgRDD.collect().foreach(println)
/*
(a,(CompactBuffer(1),CompactBuffer(4)))
(b,(CompactBuffer(2),CompactBuffer(5)))
(c,(CompactBuffer(),CompactBuffer(6, 7)))
*/

二、行动算子

所谓的行动算子，其实就是触发作业(Job)执行的方法。底层代码调用的是环境对象的runJob方法，底层代码中会创建ActiveJob，并提交执行。

1）简单算子（reduce;collect;count;first;take;takeOrdered(默认升序)）

// reduce
//val i: Int = rdd.reduce(_+_)
//println(i)
//10

// collect : 采集。方法会将不同分区的数据按照分区顺序采集到Driver端内存中，形成数组
//val ints: Array[Int] = rdd.collect()
//println(ints.mkString(","))
//1,2,3,4

// count : 数据源中数据的个数
val cnt = rdd.count()
println(cnt)
//4

// first : 获取数据源中数据的第一个
val first = rdd.first()
println(first)
//1

// take : 获取N个数据
val ints: Array[Int] = rdd.take(3)
println(ints.mkString(","))
//1,2,3

// takeOrdered : 数据排序后，取N个数据
val rdd1 = sc.makeRDD(List(4,2,3,1))
val ints1: Array[Int] = rdd1.takeOrdered(3)
println(ints1.mkString(","))
//1,2,3

2）aggregate

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

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


//10 + 13 + 17 = 40
// aggregateByKey : 初始值只会参与分区内计算
// aggregate : 初始值会参与分区内计算,并且和参与分区间计算
//val result = rdd.aggregate(10)(_+_, _+_)
val result = rdd.fold(10)(_+_)

println(result)

3）countByKey&countByValue

统计每种key/value的个数

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


//val intToLong: collection.Map[Int, Long] = rdd.countByValue()
//println(intToLong)
//Map(1 -> 3, 4 -> 1)
val stringToLong: collection.Map[String, Long] = rdd.countByKey()
println(stringToLong)
//Map(a -> 3)

4）save相关算子

// 保存成Text文件 
rdd.saveAsTextFile("output")  

// 序列化成对象保存到文件 
rdd.saveAsObjectFile("output1")  

// 保存成Sequencefile文件 必须是(k,v)类型
rdd.map((_,1)).saveAsSequenceFile("output2")

5）foreach

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

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

// foreach 其实是Driver端内存集合的循环遍历方法
rdd.collect().foreach(println)
println("******************")

// foreach 其实是Executor端内存数据打印 分布式打印
rdd.foreach(println)

/*
1
2
3
4
******************
2
3
1
4
*/

数据求学家

关注

1
点赞
踩
24

收藏

觉得还不错? 一键收藏
打赏
3
评论
Spark RDD算子详解

RDD转换算子及行动算子详细记录，附idea实操演练转换算子（Transformation）：功能的补充和封装，将旧的RDD包装成新的RDD（flatMap,map...)行动算子（Action）：触发任务的调度和作业的执行(collect)
复制链接

扫一扫