spark常用RDD算子 - 键值对关联操作 subtractByKey, join,fullOuterJoin, rightOuterJoin, leftOuterJoin

最新推荐文章于 2022-06-14 14:32:08 发布

小哇666

最新推荐文章于 2022-06-14 14:32:08 发布

阅读量349

点赞数 1

分类专栏： # spark 文章标签： spark

本文链接：https://blog.csdn.net/qq_41712271/article/details/107760718

版权

spark 专栏收录该内容

76 篇文章 0 订阅

订阅专栏

subtractByKey

函数定义

def subtractByKey[W](other: RDD[(K, W)])(implicit arg0: ClassTag[W]): RDD[(K, V)]

def subtractByKey[W](other: RDD[(K, W)], numPartitions: Int)(implicit arg0: ClassTag[W]): RDD[(K, V)]

def subtractByKey[W](other: RDD[(K, W)], p: Partitioner)(implicit arg0: ClassTag[W]): RDD[(K, V)]

类似于subtrac，删掉 RDD 中键与 other RDD 中的键相同的元素

join

函数定义

def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

def join[W](other: RDD[(K, W)], numPartitions: Int): RDD[(K, (V, W))]

def join[W](other: RDD[(K, W)], partitioner: Partitioner): RDD[(K, (V, W))]

RDD1.join(RDD2)
可以把RDD1,RDD2中的相同的key给连接起来，类似于sql中的join操作

fullOuterJoin

和join类似，不过这是全连接

leftOuterJoin

def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]

def leftOuterJoin[W](other: RDD[(K, W)], numPartitions: Int): RDD[(K, (V, Option[W]))]

def leftOuterJoin[W](other: RDD[(K, W)], partitioner: Partitioner): RDD[(K, (V, Option[W]))]

直接看图即可
对两个 RDD 进行连接操作，类似于sql中的左外连接

rightOuterJoin

对两个 RDD 进行连接操作，类似于sql中的右外连接，存在的话，value用的Some, 不存在用的None,具体的看上面的图和下面的代码即可

JavaRDD<Tuple2<Integer,Integer>> rddPre = javaSparkContext.parallelize(Arrays.asList(new Tuple2(1,2)
                , new Tuple2(3,4)
                , new Tuple2(3,6)));
JavaRDD<Tuple2<Integer,Integer>> otherPre = javaSparkContext.parallelize(Arrays.asList(new Tuple2(3,10),
                new Tuple2(4,8)));

//JavaRDD转换成JavaPairRDD
JavaPairRDD<Integer, Integer> rdd = JavaPairRDD.fromJavaRDD(rddPre);
JavaPairRDD<Integer, Integer> other = JavaPairRDD.fromJavaRDD(otherPre);


JavaPairRDD<Integer, Integer> rdd1 = rdd.subtractByKey(other);
System.out.println(rdd1.collect());
//subtractByKey算子结果演示
//[(1,2)]


JavaPairRDD<Integer, Tuple2<Integer, Integer>> join = rdd.join(other);
//join算子结果演示
//[(3,(4,10)), (3,(6,10))]


JavaPairRDD<Integer, Tuple2<Optional<Integer>, Optional<Integer>>> fullOuterJoin = rdd.fullOuterJoin(other);
System.out.println(fullOuterJoin.collect());
//fullOuterJoin算子结果演示
//[(4,(Optional.empty,Optional[8])), (1,(Optional[2],Optional.empty)),
 (3,(Optional[4],Optional[10])), (3,(Optional[6],Optional[10]))]


JavaPairRDD<Integer, Tuple2<Integer, Optional<Integer>>> leftOuterJoin = rdd.leftOuterJoin(other);
System.out.println(leftOuterJoin.collect());
//leftOuterJoin算子结果演示
//[(1,(2,Optional.empty)), (3,(4,Optional[10])), (3,(6,Optional[10]))]


JavaPairRDD<Integer, Tuple2<Optional<Integer>, Integer>> rightOuterJoin = rdd.rightOuterJoin(other);
System.out.println(rightOuterJoin.collect());
//rightOuterJoin算子结果演示
//[(4,(Optional.empty,8)), (3,(Optional[4],10)), (3,(Optional[6],10))]