Spark RDD算子详解

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

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

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

附：

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

目录

一、转换算子

1.Value类型

2.双Value类型

3.Key - Value类型

二、行动算子

---

一、转换算子

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,Iterable))类型的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
*/