第五章_Spark核心编程_Rdd算子_转换算子_2value型_求交集&并集&差集&拉链_intersection&union&subtract&zip

1. 求交集-intersection

/*
* 1. 定义
*    def intersection(other: RDD[T]): RDD[T]
*
* 2. 功能
*    对源 RDD 和参数 RDD 求交集后返回一个新的 RDD
*    参与运算的两个Rdd 类型必须一致,会对返回的结果进行去重
*
* 3. note
*    1. 内部存在 shuffle 过程
*    2. 返回结果 无重复
* */

object RddTransitionOperator_intersection extends App {
  private val sc: SparkContext = CommonUtils.getSparkContext("intersection operator")

  private val rdd: RDD[Int] = sc.parallelize(List(1, 2, 3, 3, 7, 6, 6))
  private val rdd1: RDD[Int] = sc.parallelize(List(6, 6))

  //求两个rdd的交集
  private val rdd3: RDD[Int] = rdd.intersection(rdd1, 5)

  println(s"分区个数:${rdd3.getNumPartitions}")
  println(s"类名:${rdd3.getClass.getName}")
  println(s"依赖类型:${rdd3.dependencies}")
  //  分区个数:5
  //  类名:org.apache.spark.rdd.MapPartitionsRDD
  //  依赖类型:List(org.apache.spark.OneToOneDependency@681adc8f)

  rdd3.collect().foreach(println(_))
  //6

  //sc.stop()
  while (true) {}
}

2. 求并集-union

/*
* 1. 定义
*    def union(other: RDD[T]): RDD[T]
*
* 2. 功能
*    对源 RDD 和 参数RDD 求并集后 返回一个新的RDD(分区个数为 两个rdd分区之和)
*    参与运算的两个Rdd 类型必须一致
*
* 3. note
*    1. union 操作不会对元素进行去重
*    2. 新RDD的分区个数为两个RDD的分区个数之和
*    3. 内部不存在 shuffle 过程
* */

object RddTransitionOperator_union extends App {
  private val sc: SparkContext = CommonUtils.getSparkContext("union operator")

  private val rdd: RDD[Int] = sc.parallelize(List(1, 2, 3, 3, 7, 6, 6))
  private val rdd1: RDD[Int] = sc.parallelize(List(6, 6, 9), 3)

  //求两个rdd的并集
  private val rdd3: RDD[Int] = rdd.union(rdd1)

  println(s"分区个数:${rdd3.getNumPartitions}")
  println(s"类名:${rdd3.getClass.getName}")
  println(s"依赖类型:${rdd3.dependencies}")
  //  分区个数:5
  //  类名:org.apache.spark.rdd.MapPartitionsRDD
  //  依赖类型:List(org.apache.spark.OneToOneDependency@681adc8f)

  println(rdd3.collect.mkString(","))
  //1,2,3,3,7,6,6,6,6,9

  //sc.stop()
  while (true) {}
}

3. 求差集-subtract

/*
* 1. 定义
*    def subtract(other: RDD[T]): RDD[T]
*
* 2. 功能
*    返回一个RDD(分区个数为this的分区个数),该RDD的元素 在this中,而不在other中
*    参与运算的两个Rdd 类型必须一致
*
* 3. note
*    1.不会对RDD元素去重
*    2.内部存在shuffle过程
*    3.分区个数为 父rdd的分区个数
* */

object RddTransitionOperator_subtract extends App {
  private val sc: SparkContext = CommonUtils.getSparkContext("subtract operator")

  private val rdd: RDD[Int] = sc.parallelize(List(1, 2, 3, 3, 7, 6, 6))
  private val rdd1: RDD[Int] = sc.parallelize(List(6, 6, 9), 3)

  //求两个rdd的差集
  private val rdd3: RDD[Int] = rdd.subtract(rdd1)

  println(s"分区个数:${rdd3.getNumPartitions}")
  println(s"类名:${rdd3.getClass.getName}")
  println(s"依赖类型:${rdd3.dependencies}")
  //  分区个数:10
  //  类名:org.apache.spark.rdd.MapPartitionsRDD
  //  依赖类型:List(org.apache.spark.OneToOneDependency@15ac59c2)

  println(rdd3.collect.mkString(","))
  //1,2,3,3,7

  //sc.stop()
  while (true) {}
}

4. 求拉链-zip

  object zipTest extends App {
    /*
    * 1. 定义
    *    def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]
    *
    * 2. 功能
    *    将两个 RDD 中的元素,以键值对的形式进行合并
    *    其中,键值对中的 Key 为第1个RDD中的元素
    *               Value 为第2个RDD中的相同位置的元素
    *
    * 3. 思考
    *    1. 如果两个 RDD 数据类型不一致怎么办?
    *           拉链操作两个数据源的类型可以不一致
    *
    *    2. 如果两个 RDD 数据分区不一致怎么办?
    *           Can't zip RDDs with unequal numbers of partitions: List(2, 3)
    *           分区个数必须一致
    *
    *    3. 如果两个 RDD 分区数据数量不一致怎么办?
    *           Can only zip RDDs with same number of elements in each partition
    *           分数个数相同时,分区内数据量也必须相同
    *
    * */

    val sparkconf: SparkConf = new SparkConf().setMaster("local").setAppName("distinctTest")

    val sc: SparkContext = new SparkContext(sparkconf)

    val rdd = sc.makeRDD(List(1, 2, 3, 8), 2)
    val rdd1 = sc.makeRDD(List(5, 6, 7, 8), 2)
    val rdd11 = sc.makeRDD(List(5, 6, 7, 8, 9, 10), 2)
    val rdd2 = sc.makeRDD(List("x", "y", "z", "m"), 2)
    val rdd22 = sc.makeRDD(List("x", "y", "z", "m"), 3)

    private val rdd3: RDD[(Int, Int)] = rdd.zip(rdd1)
    private val rdd4: RDD[(Int, String)] = rdd.zip(rdd2) //数据类型不一致
    //private val rdd5: RDD[(Int, String)] = rdd.zip(rdd22) //分区数量不一致
    private val rdd6 = rdd.zip(rdd11) //分区数量一致,分区内数据量不一致

    println(rdd3.collect().mkString(","))
    println(rdd4.collect().mkString(","))
    //println(rdd5.collect().mkString(","))
    println(rdd6.collect().mkString(","))

    sc.stop()
  }