spark-------------RDD 转换算子-----双 Value 类型

引言

本文主要讲一些双value类型的函数，主要用于两个RDD的操作

正文

intersection

• 函数签名:def intersection(other: RDD[T]): RDD[T]

• 函数说明:对源 RDD 和参数 RDD 求交集后返回一个新的 RDD

• 解释:必须要求两个RDD的数据类型相同

union

• 函数签名:def union(other: RDD[T]): RDD[T]

• 函数说明:对源 RDD 和参数 RDD 求并集后返回一个新的 RDD

• 解释:必须要求两个RDD的数据类型相同

subtract

• 函数签名:def subtract(other: RDD[T]): RDD[T]

• 函数说明:以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集

• 解释:必须要求两个RDD的数据类型相同。针对不同得RDD，得出的值不同

zip

• 函数签名:def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]

• 函数说明:将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD中的元素，Value 为第 2 个 RDD 中的相同位置的元素。

• 解释:要求分区数量相同，要求分区中的元素个数相同

案例:

package com.xiao.spark.core.rdd.operator.tranform

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Spark02_RDD_Operator_DoubleValue {
  def main(args: Array[String]): Unit = {
      // TODO 准备环境
      val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("transform")
      val sc = new SparkContext(sparkConf)

      val rdd1: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
      val rdd2: RDD[Int] = sc.makeRDD(List(3, 4, 5, 6))
    /**
     * 交集 并集 差集都要求元素类型一样
     * 拉链不做要求
     */
      // 交集【3，4】
      val intersectionRDD: RDD[Int] = rdd1.intersection(rdd2)
      println("交集结果"+intersectionRDD.collect().mkString(","))
      // 并集:不会去掉重复的，因为是List【1，2，3，4，3，4，5，6】
      val unionRDD: RDD[Int] = rdd1.union(rdd2)
      println("并集结果"+unionRDD.collect().mkString(","))
      // 差集：针对不同的集合，差集结果不通
      // 针对rdd1【1，2】
      // 针对rdd2【5，6】
      val subtractRDD1: RDD[Int] = rdd1.subtract(rdd2)
      val subtractRDD2: RDD[Int] = rdd2.subtract(rdd1)
      println("针对rdd1的差集:"+subtractRDD1.collect().mkString(","))
      println("针对rdd2的差集:"+subtractRDD2.collect().mkString(","))
      // 拉链【(1,3),(2,4),(3,5),(4,6)】
      // 要求分区数量相同，要求分区中的元素个数相同
      val zipRDD: RDD[(Int, Int)] = rdd1.zip(rdd2)
      println("拉链结果为:"+zipRDD.collect().mkString(","))

    // TODO 关闭环境
      sc.stop()
  }
}

运行结果: