Spark Core RDD详解

Spark Core:

1.RDD （resilient distributed dataset）弹性的分布式数据集
描述信息：编程的目的 从哪里读数据，调用了什么方法,传入了什么函数。

2.RDD：五大特征A list of partitions RDD有一系列的分区组成,
A function for computing each split 函数作用在每一个切片（分区）一个分区，一个task，每个task的计算逻辑 一样，处理的数据不一样
A list of dependencies on other RDDs
Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned) Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)

3.RDD的算子：
3.1.transformation：（map、flatMap、filter、mapPartitions、mapValues、mapPartitionsWithIndex、sortBy、repartition、coalesce、distinct、sample、join、leftOuterJoin、rightOuterJoin、fullOuterJoin、cogroup、groupByKey、reduceBykey、foldByKey、aggregateByKey、combineByKey、sortByKey、union、zip…）

3.2.action ：（count、take、foreach、foreachPartition、saveAsTextFile、collect、reduce、aggregate…）

3.3.cache、persist、checkpoint

4.application、driver、Executor、DAG、job、stage、task、client、cluster

5.application的执行流程：spark on yarn

6.ResultTask、ShuffleMapTask
textFile()->faltMap->Map(ShuffleMapTask)
reduceByKey->saveAsTextFile(ResultTask)

RDD算子详解
transformation:

transformation RDD

map：

函数公式：def map[U: ClassTag](f: T => U): RDD[U]
将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)

  val DataRDD1: RDD[Int] = sc.parallelize(1 to 5)
    DataRDD1.collect().foreach(println)
/* 结果：
    1
    2
    3
    4
    5*/
    //map 对前一个rdd里面传过来的数据，每一个元素做一个操作
    val DataRDD2: RDD[Int] = DataRDD1.map(x=>x*2)   //简写DataRDD1.map(_*2)
    println("----------分割线-----------")
    DataRDD2.collect().foreach(println)
/* 结果：
    2
    4
    6
    8
    10*/

    //使用map将普通RDD转换成pairRDD
     val DataRDD3: RDD[(Int, Int)] = DataRDD1.map(x=>(x,1))
    println("----------分割线-----------")
    println(DataRDD3.collect().mkString("--"))
//   结果： (1,1)--(2,1)--(3,1)--(4,1)--(5,1)
    sc.stop()
  }
}

mapPartitions：

函数公式：def mapPartitions[U: ClassTag]( f: Iterator[T] => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)

    val RDDData1: RDD[Int] = sc.parallelize(1 to 5)
    //map 对前一个rdd里面传过来的数据，每一个元素做一个操作
    val RDDData2: RDD[Int] = RDDData1.map(x=>x*2)
    RDDData2.collect().foreach(println)
/*    结果：
    2
    4
    6
    8
    10*/
    println("---------分割线------------")
    //mapPartitions每次处理一个分区的数据
    val RDD2: RDD[Int] = RDDData1.mapPartitions(x=>x.map(_*2))
    println(RDD2.collect().mkString(" "))
//    结果：2 4 6 8 10
    sc.stop()
  }
}

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

mapPartitionsWithIndex:
函数公式：def mapPartitionsWithIndex[U: ClassTag](f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。
与mapPartitions类似，但为 func多提供一个分区编号
mapPartitionsWithIndex的func接受两个参数，第一个参数是分区的索引，第二个是一个数据集分区的迭代器。而输出的是一个包含经过该函数转换的迭代器。下面测试中，将分区索引和分区数据一起输出

val x = sc.parallelize(List(1,2,3,4,5,6,7,8,9,10),3)
def myfunc(index:Int,iter:Iterator[Int]):Iterator[String] = {
    
    
iter.toList.map(x => index + "-" + x ).iterator
}
//myfunc:(index:Int,iter:Iterator[Int]):Iterator[String]

x.mapPartitionsWithIndex(myfunc).collect()
或者
object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),2)
    //     获取数据与所对应的分区
    val mapRdd: RDD[(Int, Int)] = rdd.mapPartitionsWithIndex(
      (index, datas) => {
    
    
        datas.map((index, _))
      }
    )
    println(mapRdd.collect.mkString(","))
  //结果：(0,1),(0,2),(0,3),(1,4),(1,5),(1,6)
    sc.stop()
  }
}

filter:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val RDDData1: RDD[Int] = sc.parallelize(1 to 5)
    //过滤满足a中元素能被2整除则转化为RDD RDDData2
      val RDDDat2: RDD[Int] = RDDData1.filter(x=>x%2==0)
    println(RDDDat2.collect().mkString("  "))
    //结果：2  4
    sc.stop()

  }
}

distinct:

将数据集中重复的数据去重
函数公式：
def distinct()(implicit ord: Ordering[T] = null): RDD[T]
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

val rdd1 = sc.parallelize(Array("A", "B", "C","D","A"))
rdd1.distinct.collect()
//res1: Array[String] = Array(B, A, C, D) 返回字段的顺序可能会不一致
或者
object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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()
  }
}

groupBy:

函数公式：def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，这样
的操作称之为 shuffle。极限情况下，数据可能被分在同一个分区中
一个组的数据在一个分区中，但是并不是说一个分区中只有一个组

val rdd = sc.parallelize(List('a','a','b','b','c','c'))
rdd.collect()
rdd.map((_,1)).collect()    
rdd.map((_,1)).groupByKey().map(x => (x._1,x._2.sum)).collect.foreach(println)
或
object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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","zhangsan","lisi","wangwu"),2)
    val groupByRdd1: RDD[(String, Iterable[String])] = rdd1.groupBy(
      _.substring(0, 1)
    )
    groupByRdd1.collect.foreach(println)
    //结果：(z,CompactBuffer(zhangsan))
    //(h,CompactBuffer(hello))
    //(l,CompactBuffer(lisi))
    //(w,CompactBuffer(wangwu))
    sc.stop()
  }
}

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 的过程

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,6,8,4,9,5,7,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()
  }
}

join:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
    val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 11), (2, 22), (3, 33)))
    rdd.join(rdd1).collect().foreach(println)
    //结果：(1,(a,11))
    //(3,(c,33))
    //(2,(b,22))
    sc.stop()
  }
}

leftOuterJoin:

函数公式：def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
类似于 SQL 语句的左外连接

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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)
  //结果：(a,(1,Some(1)))
    //(a,(1,Some(2)))
    //(b,(2,None))
    //(c,(3,Some(3)))
    sc.stop()
  }
}

rightOuterJoin：

类似于 SQL 语句的右外连接

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3)))
    val dataRDD2 = sc.makeRDD(List(("a",1),("a",2),("c",3)))
    val rightJoinRDD = dataRDD1.rightOuterJoin(dataRDD2)
    rightJoinRDD.collect().foreach(println)
  //结果：(a,(Some(1),1))
    //(a,(Some(1),2))
    //(c,(Some(3),3))
    sc.stop()
  }
}

fullOuterJoin:

类似于 SQL 语句的全连接

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3)))
    val dataRDD2 = sc.makeRDD(List(("a",1),("a",2),("c",3)))
    val fullJoinRDD = dataRDD1.fullOuterJoin(dataRDD2)
    fullJoinRDD.collect().foreach(println)
  //结果：(a,(Some(1),Some(1)))
    //(a,(Some(1),Some(2)))
    //(b,(Some(2),None))
    //(c,(Some(3),Some(3)))
    sc.stop()
  }
}

reduceByKey：

函数公式:def reduceByKey(func: (V, V) => V): RDD[(K, V)]
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
可以将数据按照相同的 Key 对 Value 进行聚合
没有初始值，分区内和分区间的计算逻辑一致

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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()
  }
}

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 进行分组

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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()
  }
}

mapValues：

函数公式：val newRdd = oldRdd. mapValues(func)
针对于(K,V)形式的类型只对V进行操作

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val arrayRdd = sc.makeRDD(Array((1,"小红"),(2,"李四"),(3,"王五"),(4,"张三")))
    val mapRdd = arrayRdd.mapValues(_+"?")
    mapRdd.collect().foreach(println)
    //结果：(1,小红?)
    //(2,李四?)
    //(3,王五?)
    //(4,张三?)
    sc.stop()
  }
}

sortByKey：

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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()
  }
}

cogroup：

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
    val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 11), (2, 22), (3, 33)))
    rdd.cogroup(rdd1).collect().foreach(println)
  //结果：(1,(CompactBuffer(a),CompactBuffer(11)))
    //(3,(CompactBuffer(c),CompactBuffer(33)))
    //(2,(CompactBuffer(b),CompactBuffer(22)))
    sc.stop()
  }
}

flatMap:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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 张三", "hello lisi"))
    val flatRdd1: RDD[String] = rdd1.flatMap(
      str => str.split(" ")
    )
    println(flatRdd1.collect.mkString(",")) //结果：hello,张三,hello,lisi
     sc.stop()
  }
}

glom：

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6), 2)
    val glomRdd: RDD[Array[Int]] = rdd.glom()
    glomRdd.collect.foreach(data => println(data.mkString(",")))
    //结果： 1,2,3
    //4,5,6
     sc.stop()
  }
}

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计数的精确部分。

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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.5, 1
    )
    println(sampleRdd.collect.mkString(","))  //结果：1,3,4,5,8,10
    sc.stop()
  }
}

coalesce：

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10),3)
    //val newRdd: RDD[Int] = rdd.coalesce(2)
    //默认不会重新打乱重新组合，第二个参数为是否执行shuffle
    val newRdd: RDD[Int] = rdd.coalesce(2,true)
    newRdd.saveAsTextFile("file:///F:/JavaTest/SparkDemo/data/SparkData/OutPut")
    sc.stop()
  }
}

repartition：

函数公式：def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope { coalesce(numPartitions, shuffle = true) }
随机地重新Shuffle RDD中的数据，以创建更多或更少的分区，并在它们之间进行平衡
无论是将分区数多的RDD 转换为分区数少的 RDD，还是将分区数少的 RDD 转换为分区数多的 RDD，repartition 操作都可以完成，因为无论如何都会经 shuffle 过程。

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10),3)
    val newRdd: RDD[Int] = rdd.repartition(4)
    newRdd.saveAsTextFile("file:///F:/JavaTest/SparkIPMappingDemo/data/SparkData/OutPut")
    sc.stop()
  }
}

双Value类型：

intersection：

函数公式：def intersection(other: RDD[T]): RDD[T]
返回两个数据集的交集，即两个RDD中都有的元素，会去重，单个RDD中重复的元素会去除 ( intersection() 与 union() 的概念相似，intersection() 的性能却要差很多，因为它需要通过网络混洗数据来发现共有的元素 )

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4,5))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6,7))
    val dataRDD = dataRDD1.intersection(dataRDD2)
    println(dataRDD.collect.mkString(","))   // 结果：4,3,5
    sc.stop()
  }
}

union：

函数公式：def union(other: RDD[T]): RDD[T]
返回一个新数据集，该数据集包含源数据集中的元素和参数的并集
union 返回两个数据集的并集，不会进行去重，union 不是按照列名合并的，而是按照位置合并的，即合并时需将每一列的位置一一对应。并没有 unionAll 算子，但是在 spark sql 中，union 有去重的功能，而 union all 不去重

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4,5))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6,7))
    val dataRDD = dataRDD1.union(dataRDD2)
    println(dataRDD.collect.mkString(","))   //结果：1,2,3,4,5,3,4,5,6,7
    sc.stop()
  }
}

subtract:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4,5))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6,7))
    val dataRDD = dataRDD1.subtract(dataRDD2)
    println(dataRDD.collect.mkString(","))
    //结果：1,2
    sc.stop()
  }
}

zip：

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val dataRDD1 = sc.makeRDD(List(1,2,3,4,5))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6,7))
    val dataRDD = dataRDD1.zip(dataRDD2)
    println(dataRDD.collect.mkString(","))
    //结果：(1,3),(2,4),(3,5),(4,6),(5,7)
    sc.stop()
  }
}

k-v类型

partitionBy：

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[(Int, String)] =
      sc.makeRDD(Array((1,"a"),(2,"b"),(3,"c")),3)
    import org.apache.spark.HashPartitioner
    val rdd2: RDD[(Int, String)] =
      rdd.partitionBy(new HashPartitioner(2))
     rdd2.saveAsTextFile("file:///F:/JavaTest/SparkDemo/data/SparkData/OutPut")
    sc.stop()
  }
}

aggregateByKey：

函数公式：def aggregateByKey[U: ClassTag](zeroValue: U, partitioner: Partitioner)(seqOp: (U, V) => U,combOp: (U, U) => U): RDD[(K, U)]
将数据根据不同的规则进行分区内计算和分区间计算
有初始值，传入连个函数，一个用于分区内，一个用于分区间

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    //  取出每个分区内相同 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)
    sc.stop()
  }
}

foldByKey：

函数公式：def foldByKey(zeroValue: V,partitioner: Partitioner)(func: (V, V) => V): RDD[(K, V)]
有初始值（可以和分区内 的值不一致） 分区内和分区间的计算逻辑一致
当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为 foldByKey

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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()
  }
}

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()允许用户返回值的类型与输入不一致。
传入三个函数，第一函数处理第一值，一个用于分区内，一个用于分区间

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(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)
    //结果：(b,(4,1))
    //(a,(3,2))
    //(c,(14,3))
    sc.stop()
  }
}

常用行动算子

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

reduce:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
    println(rdd.reduce(_ + _)) //结果：15
    sc.stop()
  }
}

collect:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
    println(rdd.collect().mkString(","))
    //结果：1,2,3,4,5
    sc.stop()
  }
}

count:

函数公式：def count(): Long
返回 RDD 中元素的个数

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
    println(rdd.count())
    //结果：5
    sc.stop()
  }
}

first:

函数公式：def first(): T
返回 RDD 中的第一个元素

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
    println(rdd.first())
    //结果：1
    sc.stop()
  }
}

take:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
    println(rdd.take(3).mkString(","))
    //结果：1,2,3
    sc.stop()
  }
}

takeOrdered:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
    println(rdd.takeOrdered(3).mkString(",")) 
    //结果:1,2,3
    println(rdd.takeOrdered(3)(Ordering.Int.reverse).mkString(","))
    //结果：5,4,3
    sc.stop()
  }
}

aggregate:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5),2)
    println(rdd.aggregate(10)(_ + _, _ + _))
    //结果：45
    sc.stop()
  }
}

fold:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5),2)
    println(rdd.fold(10)(_ + _))
    //结果：45
    sc.stop()
  }
}

countByKey:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    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()
  }
}

countByValue:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,6,5,3,2))
    println(rdd.countByValue()) 
    //结果：Map(5 -> 1, 1 -> 1, 6 -> 1, 2 -> 2, 3 -> 2, 4 -> 1)
    sc.stop()
  }
}

save 相关算子:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
    rdd.saveAsTextFile("file:///F:/JavaTest/SparkDemo/data/SparkData/OutPut1")
    rdd.saveAsObjectFile("file:///F:/JavaTest/SparkDemo/data/SparkData/OutPut2")
    //    要求数据格式必须为k-v类型
    rdd.saveAsSequenceFile("file:///F:/JavaTest/SparkDemo/data/SparkData/OutPut3")
    sc.stop()
  }
}

foreach:

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

object SparkRDDTest {
    
    
  def main(args:Array[String]):Unit= {
    
    
    val conf: SparkConf = new SparkConf().setMaster("local").setAppName("SparkRDD")
    val sc: SparkContext = SparkContext.getOrCreate(conf)
    val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
    //    收集后打印，在Driver端内存集合的循环遍历方法
    rdd.collect.foreach(println)  //此处使用的是scala的函数
    println("-------------------分割线-------------------")
    //    分布式打印，在Executor端内存数据打印
    rdd.foreach(println)        // 这里使用的是RDD的算子
/*
  结果：
    1
    2
    3
    4
    5
    -------------------分割线-------------------
    1
    2
    3
    4
    5
*/
    sc.stop()
  }
}