SparkRDD常用算子

一、概念

• 在Spark中，算子是指用于处理RDD（弹性分布式数据集）的基本操作。算子可以分为两种类型：转换算子和行动算子。
• 转换算子：
  转换算子是将一个RDD转换为另一个RDD的操作，不会立即执行，而是创建一个新的RDD，以记录转换的方式和参数，然后等待后续的行动算子触发计算。
• 行动算子：
  行动算子是触发计算并返回结果的操作。它们会立即对RDD进行计算，然后将结果返回给驱动程序或存储到文件系统等。

二、常用转换算子

2.1、map

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

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

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

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

    println(rdd.map(x => x * 2).collect().mkString(","))
    sc.stop()
    // 结果：2,4,6,8

2.2、mapPartitions

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

可以以分区为单位进行数据转换操作，但是会将整个分区的数据加载到内存中引用，处理完的数据是不会被释放掉，存在对象的引用，在内存较小，数据量较大的情况下会出现内存溢出(OOM)

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

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

    val dataRDD1: RDD[Int] = rdd.mapPartitions(
      datas => {
      //几个分区就会打印几次>>>>>>>>>>>>>
        println(">>>>>>>>>>>>>")
        datas.map(_*2)
      }
    )
    println(dataRDD1.collect().mkString(","))
    sc.stop()
    //>>>>>>>>>>>>>
		//>>>>>>>>>>>>>
		//2,4,6,8

map与mapPartitions区别：

• 数据处理
  • map算子是分区内一个数据一个数据的执行
  • mapPartitions算子是以分区为单位进行批处理操作。
• 功能
  • map算子主要目的是将数据源中的数据进行转换和改变。不会减少或增多数据
  • mapPartitions算子需要传递一个迭代器，返回一个迭代器，没有要求元素的个数保持不变，可以增加或减少数据
• 性能
  • map算子类似于串行操作，性能较低
  • mapPartitions算子类似于批处理，性能较高。

2.3、mapPartitionsWithIndex

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

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

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

    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
// 	获取数据与所对应的分区
    val mapRdd: RDD[(Int, Int)] = rdd.mapPartitionsWithIndex(
      (index, datas) => {
        datas.map((index, _))
      }
    )
    println(mapRdd.collect.mkString(","))
    sc.stop()

2.4、flatMap

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射

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

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

    val flatRdd: RDD[Int] = rdd.flatMap(
      list => {
        list
      }
    )
    println(flatRdd.collect.mkString(",")) // 1,2,3,4
    val rdd1: RDD[String] = sc.makeRDD(List("hello world", "hello spark"))
    val flatRdd1: RDD[String] = rdd1.flatMap(
      str => str.split(" ")
    )
    println(flatRdd1.collect.mkString(",")) //hello,world,hello,spark
    sc.stop()

2.5、glom

def glom(): RDD[Array[T]]
将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)

    val glomRdd: RDD[Array[Int]] = rdd.glom()

    glomRdd.collect.foreach(data => println(data.mkString(",")))

    sc.stop()

2.6、groupBy

**def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])] **
将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组，相同的key值的数据会放置一个组中。

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

    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
//    groupby会将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组，相同的key值的数据会放置一个组中。
    val groupByRdd: RDD[(Int, Iterable[Int])] = rdd.groupBy(
      _ % 2
    )
    groupByRdd.collect.foreach(println) //    (0,CompactBuffer(2, 4))
                                        //(1,CompactBuffer(1, 3))

    val rdd1: RDD[String] = sc.makeRDD(List("hello","hi","spark","sqoop"),2)
    //    
    val groupByRdd1: RDD[(String, Iterable[String])] = rdd1.groupBy(
      _.substring(0, 1)
    )
    groupByRdd1.collect.foreach(println)    //(h,CompactBuffer(hello, hi))
                                            //(s,CompactBuffer(spark, sqoop))
    sc.stop()

2.7、filter

**def filter(f: T => Boolean): RDD[T] **
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。

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

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

    val filterRdd: RDD[Int] = rdd.filter(
      _ % 2 != 0
    )
    println(filterRdd.collect.mkString(",")) //1,3
    sc.stop()

2.8、sample

def sample(withReplacement: Boolean,fraction: Double,seed: Long = Utils.random.nextLong): RDD[T]
返回此RDD的抽样子集。
形参:

• withReplacement -抽取后数据是否被放回 ，放回（true），不放回（false）
• fraction——样本的期望大小是该RDD大小的一个分数，不需要替换:每个元素被选中的概率;分数必须为[0,1]，替换为:每个元素被选择的预期次数;分数必须大于或等于0
• seed-用于随机数生成器的种子 ,在种子确定后，并且fraction没有变的时候，结果是不会变的。
• 注意: 这并不能保证提供给定RDD计数的精确部分。

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

    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4,5,6,7,8,9,10),1)

    val sampleRdd: RDD[Int] = rdd.sample(
      true, 0.4, 1
    )
    println(sampleRdd.collect.mkString(","))  //1,6,6
    sc.stop()

2.9、distinct

def distinct(): RDD[T]
将数据集中重复的数据去重

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

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

    println(rdd.distinct().collect.mkString(","))	//4,1,3,10,5,2
    sc.stop()

2.10、coalesce

def coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty)(implicit ord: Ordering[T] = null) : RDD[T]
根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率
当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本

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

    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4,5,6),3)
    
    //val newRdd: RDD[Int] = rdd.coalesce(2)
    //默认不会重新打乱重新组合，第二个参数为是否执行shuffle
    val newRdd: RDD[Int] = rdd.coalesce(2,true)
    newRdd.saveAsTextFile("output")
    sc.stop()

2.11、repartition

源码

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
    coalesce(numPartitions, shuffle = true)
  }

无论是将分区数多的RDD 转换为分区数少的 RDD，还是将分区数少的 RDD 转换为分区数多的 RDD，repartition
操作都可以完成，因为无论如何都会经 shuffle 过程。
示例

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

    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4,5,6),3)
    val newRdd: RDD[Int] = rdd.repartition(4)
    newRdd.saveAsTextFile("output")
    sc.stop()

2.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 conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)

    val rdd: RDD[Int] = sc.makeRDD(List(1, 2,7,8,9,4,5,6 ,3 ,10),2)

    val sortByRdd: RDD[Int] = rdd.sortBy(
      num => num
    )
    println(sortByRdd.collect.mkString(","))  //1,2,3,4,5,6,7,8,9,10
    sc.stop()

2.13、intersection

def intersection(other: RDD[T]): RDD[T]
对源 RDD 和参数 RDD 求交集后返回一个新的 RDD

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6))
    val dataRDD = dataRDD1.intersection(dataRDD2)
    println(dataRDD.collect.mkString(","))   // 3,4
    sc.stop()

2.14、union

def union(other: RDD[T]): RDD[T]
对源 RDD 和参数 RDD 求并集后返回一个新的 RDD

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6))
    val dataRDD = dataRDD1.union(dataRDD2)
    println(dataRDD.collect.mkString(","))   //1,2,3,4,3,4,5,6
    sc.stop()

2.15、subtract

def subtract(other: RDD[T]): RDD[T]
以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6))
    val dataRDD = dataRDD1.subtract(dataRDD2)
    println(dataRDD.collect.mkString(","))			// 1,2
    sc.stop()

2.16、zip

def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]
将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD中的元素，Value 为第 2 个 RDD 中的相同位置的元素。两个数据源要求分区数量一致，并且数据源分区中数据数量保持一致。

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6))
    val dataRDD = dataRDD1.zip(dataRDD2)
    println(dataRDD.collect.mkString(","))
    sc.stop()

2.17、partitionBy

def partitionBy(partitioner: Partitioner): RDD[(K, V)]
将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner 还有一个分区器：RangePartitioner

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val rdd: RDD[(Int, String)] =
      sc.makeRDD(Array((1,"aaa"),(2,"bbb"),(3,"ccc")),3)
    import org.apache.spark.HashPartitioner
    val rdd2: RDD[(Int, String)] =
      rdd.partitionBy(new HashPartitioner(2))
    rdd2.saveAsTextFile("output")   //分区一:(2,bbb)  分区二：(1,aaa)(3,ccc)
    sc.stop()

2.18、reduceByKey

def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)]
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
可以将数据按照相同的 Key 对 Value 进行聚合
若key的数据只有一个时，不会参与运算。

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3),("a",1),("a",2),("c",3)))
    val dataRDD2 = dataRDD1.reduceByKey(_+_)
    val dataRDD3 = dataRDD1.reduceByKey(_+_, 2)

    println(dataRDD2.collect.mkString)	//(a,4)(b,2)(c,6)
    println(dataRDD3.collect.mkString)	//(b,2)(a,4)(c,6)
    sc.stop()

2.19、groupByKey

def groupByKey(): RDD[(K, Iterable[V])]
def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])]
def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]
将数据源的数据根据 key 对 value 进行分组

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val rdd = sc.makeRDD(List(("a",1),("b",2),("c",3),("a",1),("a",2),("c",3)))
    println(rdd.groupByKey().collect.mkString(",")) //(a,CompactBuffer(1, 1, 2)),(b,CompactBuffer(2)),(c,CompactBuffer(3, 3))
    sc.stop()

2.20、aggregateByKey

def aggregateByKey[U: ClassTag](zeroValue: U, partitioner: Partitioner)(seqOp: (U, V) => U,combOp: (U, U) => U): RDD[(K, U)]
将数据根据不同的规则进行分区内计算和分区间计算

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    // TODO : 取出每个分区内相同 key 的最大值然后分区间相加
    // aggregateByKey 算子是函数柯里化，存在两个参数列表
    // 1. 第一个参数列表中的参数表示初始值
    // 2. 第二个参数列表中含有两个参数
    // 2.1 第一个参数表示分区内的计算规则
    // 2.2 第二个参数表示分区间的计算规则
    val rdd =
    sc.makeRDD(List(
      ("a",1),("a",2),("c",3),
      ("b",4),("c",5),("c",6)
    ),2)
    // 0:("a",1),("a",2),("c",3) => (a,10)(c,10)
    // => (a,10)(b,10)(c,20)
    // 1:("b",4),("c",5),("c",6) => (b,10)(c,10)
    val resultRDD =
    rdd.aggregateByKey(0)(
      (x, y) => math.max(x,y),
      (x, y) => x + y
    )
    resultRDD.collect().foreach(println)
//结果：(b,4)
//(a,2)
//(c,9)

2.21、foldByKey

def foldByKey(zeroValue: V,partitioner: Partitioner)(func: (V, V) => V): RDD[(K, V)]
当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为 foldByKey

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val rdd =
    sc.makeRDD(List(
      ("a",1),("a",2),("c",3),
      ("b",4),("c",5),("c",6)
    ),2)

    val foldRdd: RDD[(String, Int)] = rdd.foldByKey(0)(_ + _)
    println(foldRdd.collect.mkString(",")) //(b,4),(a,3),(c,14)

    sc.stop()

2.22、combineByKey

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 conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val rdd =
      sc.makeRDD(List(
        ("a",1),("a",2),("c",3),
        ("b",4),("c",5),("c",6)
      ),2)
      // 第一个参数：将相同key的第一个数据进行结构化的转换，实现操作。
      // 第二个参数：分区内的计算规则
      // 第三个参数：分区间的计算规则
    val combineRdd: RDD[(String, (Int, Int))] = rdd.combineByKey(
      (_, 1),
      (acc: (Int, Int), v) => (acc._1 + v, acc._2 + 1),
      (acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
    )
    combineRdd.collect.foreach(println)
    sc.stop()
//结果：
//(b,(4,1))
//(a,(3,2))
//(c,(14,3))

2.23、sortByKey

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length) : RDD[(K, V)]
在一个(K,V)的 RDD 上调用，K 必须实现 Ordered 接口(特质)，返回一个按照 key 进行排序
的

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3)))
    val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)
    val sortRDD2: RDD[(String, Int)] = dataRDD1.sortByKey(false)
    println(sortRDD1.collect.mkString(",")) //(a,1),(b,2),(c,3)
    println(sortRDD2.collect.mkString(",")) //(c,3),(b,2),(a,1)
    sc.stop()

2.23、join

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

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
    val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6)))
    rdd.join(rdd1).collect().foreach(println)

    sc.stop()
// 结果：
// (1,(a,4))
// (2,(b,5))
// (3,(c,6))

2.24、leftOuterJoin

def leftOuterJoin[W](other: RDD[(K, W)],partitioner: Partitioner): RDD[(K, (V, Option[W]))]
类似于 SQL 语句的左外连接

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3)))
    val dataRDD2 = sc.makeRDD(List(("a",1),("a",2),("c",3)))
    val rdd: RDD[(String, (Int, Option[Int]))] = dataRDD1.leftOuterJoin(dataRDD2)

    rdd.collect.foreach(println)
    sc.stop()
//结果：
//(a,(1,Some(1)))
//(a,(1,Some(2)))
//(b,(2,None))
//(c,(3,Some(3)))

2.25、cogroup

def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]
在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc: SparkContext = new SparkContext(conf)
    val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
    val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6)))
    rdd.cogroup(rdd1).collect().foreach(println)

    sc.stop()
// 结果：
// (1,(CompactBuffer(a),CompactBuffer(4)))
// (2,(CompactBuffer(b),CompactBuffer(5)))
// (3,(CompactBuffer(c),CompactBuffer(6)))

三、常用行动算子

• 触发作业（Job）执行的方法
• 底层代码中调用的是环境对象的runJob方法
• 底层代码中会创建ActiveJob，并提交执行

3.1、reduce

def reduce(f: (T, T) => T): T
聚集 RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

    println(rdd.reduce(_ + _)) //10
    sc.stop()

3.2、collect

def collect(): Array[T]
在驱动程序中，以数组 Array 的形式返回数据集的所有元素

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

    println(rdd.collect().mkString(",")) //1,2,3,4
    sc.stop()

3.3、count

def count(): Long
返回 RDD 中元素的个数

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

    println(rdd.count()) //4
    sc.stop()

3.4、first

def first(): T
返回 RDD 中的第一个元素

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

    println(rdd.first())  //1
    sc.stop()

3.5、take

def take(num: Int): Array[T]
返回一个由 RDD 的前 n 个元素组成的数组

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

    println(rdd.take(2).mkString(","))  //1,2
    sc.stop()

3.6、takeOrdered

def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]
返回该 RDD 排序后的前 n 个元素组成的数组

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,3, 4,8,5 ))

    println(rdd.takeOrdered(3).mkString(","))  //1,3,4
    println(rdd.takeOrdered(3)(Ordering.Int.reverse).mkString(",")) //8,5,4
    sc.stop()

3.7、aggregate

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U
分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合
会参与分区内计算，也会参与分区间计算

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)

    println(rdd.aggregate(10)(_ + _, _ + _)) //40

    sc.stop()

3.8、fold

def fold(zeroValue: T)(op: (T, T) => T): T
折叠操作，aggregate 的简化版操作

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)

    println(rdd.fold(10)(_ + _)) //40

    sc.stop()

3.9、countByKey

def countByKey(): Map[K, Long]
统计每种 key 的个数

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2,
      "b"), (3, "c"), (3, "c")))
    println(rdd.countByKey()) //Map(1 -> 3, 2 -> 1, 3 -> 2)
    sc.stop()

3.9、countByValue

def countByValue()(implicit ord: Ordering[T] = null): Map[T, Long]
返回此RDD中每个唯一值的计数，作为(value, count)对的本地映射

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,3, 4,8,5,1,3, 4 ))

    println(rdd.countByValue()) //Map(5 -> 1, 1 -> 2, 3 -> 2, 8 -> 1, 4 -> 2)
    sc.stop()

3.10、save 相关算子

def saveAsTextFile(path: String): Unit
def saveAsObjectFile(path: String): Unit
def saveAsSequenceFile(path: String,codec: Option[Class[_ <: CompressionCodec]] = None): Unit
将数据保存到不同格式的文件中

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("a", 2), ("a", 3)))

    rdd.saveAsTextFile("output")
    rdd.saveAsObjectFile("output1")
//    要求数据格式必须为k-v类型
    rdd.saveAsSequenceFile("output2")

    sc.stop()

3.11、foreach

def foreach(f: T => Unit): Unit
分布式遍历 RDD 中的每一个元素，调用指定函数

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("action")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

//    收集后打印，在Driver端内存集合的循环遍历方法
    rdd.collect.foreach(println)  //此处使用的是scala的函数
    println("_-----------------------")
//    分布式打印，在Executor端内存数据打印
    rdd.foreach(println)		// 这里使用的是RDD的算子
    sc.stop()