Spark RDD算子之关联操作 -- join、fullOuterJoin、leftOuterJoin、rightOuterJoin、subtractByKey

最新推荐文章于 2024-07-09 10:41:03 发布
最新推荐文章于 2024-07-09 10:41:03 发布
阅读量2k 收藏 6
点赞数 4
分类专栏： Spark 文章标签： spark scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42578036/article/details/109595591
版权

1、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，RDD2中的相同的 key 给连接起来，类似于 sql 中的 join 操作；若有多个相同的 key 则连接多次，仔细查看比较运行结果

Scala版本

    val conf = new SparkConf().setAppName("JoinScala").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List(("a",1),("c",2),("a",3),("b",4),("c",5),("d",6)))
    val rdd2 = sc.parallelize(List(("b",5),("c",4),("a",6),("a",9),("c",3),("d",2)))
    val join = rdd1.join(rdd2)
    join.collect.foreach(println)

运行结果如下：

在这里插入图片描述
Java版本

SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("JoinJava");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<Tuple2<Integer, Character>> rdd1 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(1, 'a'),
                new Tuple2<Integer, Character>(2, 'b'),
                new Tuple2<Integer, Character>(3, 'c'),
                new Tuple2<Integer, Character>(3, 'd')
        ));
        JavaRDD<Tuple2<Integer, Character>> rdd2 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(2, 'x'),
                new Tuple2<Integer, Character>(3, 'y'),
                new Tuple2<Integer, Character>(4, 'z')
        ));
//转化成PairRDD
        JavaPairRDD<Integer, Character> pairRdd1 = JavaPairRDD.fromJavaRDD(rdd1);
        JavaPairRDD<Integer, Character> pairRdd2 = JavaPairRDD.fromJavaRDD(rdd2);
 
        JavaPairRDD<Integer, Tuple2<Character, Character>> joinRdd = pairRdd1.join(pairRdd2);
        java.util.Map<Integer, Tuple2<Character, Character>> joinMap = joinRdd.collectAsMap();
        Set<Integer> keys = joinMap.keySet();
        for (Integer key :
                keys) {
            System.out.println(keys+" : "+joinMap.get(key));
        }

运行结果如下：

在这里插入图片描述

2、fullOuterJoin

全连接，仔细查看比较运行结果

Scala版本

	val conf = new SparkConf().setAppName("fullOuterJoin").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List(("a",1),("c",2),("b",4),("d",6)))
    val rdd2 = sc.parallelize(List(("b",5),("c",4),("a",9),("d",2)))
    val fullOut = rdd1.fullOuterJoin(rdd2)
    fullOut.collect.foreach(println)

运行结果如下：

在这里插入图片描述
Java版本

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("fullOuterJoin");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<Tuple2<Integer, Character>> rdd1 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(1, 'a'),
                new Tuple2<Integer, Character>(2, 'b'),
                new Tuple2<Integer, Character>(3, 'c'),
                new Tuple2<Integer, Character>(3, 'd')
        ));
        JavaRDD<Tuple2<Integer, Character>> rdd2 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(2, 'x'),
                new Tuple2<Integer, Character>(3, 'y'),
                new Tuple2<Integer, Character>(4, 'z')
        ));
//转化成PairRDD
        JavaPairRDD<Integer, Character> pairRdd1 = JavaPairRDD.fromJavaRDD(rdd1);
        JavaPairRDD<Integer, Character> pairRdd2 = JavaPairRDD.fromJavaRDD(rdd2);
        JavaPairRDD<Integer, Tuple2<org.apache.spark.api.java.Optional<Character>, org.apache.spark.api.java.Optional<Character>>> fullOuterJoinRdd = pairRdd1.fullOuterJoin(pairRdd2);
        java.util.Map<Integer, Tuple2<org.apache.spark.api.java.Optional<Character>, org.apache.spark.api.java.Optional<Character>>> fullOuterJoinMap = fullOuterJoinRdd.collectAsMap();
        Set<Integer> keys1 = fullOuterJoinMap.keySet();
        for (Integer key :
                keys1) {
            System.out.println(key+" : "+fullOuterJoinMap.get(key));
        }

运行结果如下：

在这里插入图片描述

3、leftOuterJoin

对两个 RDD 进行连接操作，类似于sql中的左外连接，仔细查看比较运行结果

Scala版本

    val conf = new SparkConf().setAppName("leftOuterJoin").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List(("a",1),("c",2),("b",4),("d",6)))
    val rdd2 = sc.parallelize(List(("b",5),("a",9),("d",2)))
    val left = rdd1.leftOuterJoin(rdd2)
    left.collect.foreach(println)

运行结果如下：

在这里插入图片描述
Java版本

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("leftOuterJoin");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<Tuple2<Integer, Character>> rdd1 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(1, 'a'),
                new Tuple2<Integer, Character>(2, 'b'),
                new Tuple2<Integer, Character>(3, 'c'),
                new Tuple2<Integer, Character>(3, 'd')
        ));
        JavaRDD<Tuple2<Integer, Character>> rdd2 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(2, 'x'),
                new Tuple2<Integer, Character>(3, 'y'),
                new Tuple2<Integer, Character>(4, 'z')
        ));
//转化成PairRDD
        JavaPairRDD<Integer, Character> pairRdd1 = JavaPairRDD.fromJavaRDD(rdd1);
        JavaPairRDD<Integer, Character> pairRdd2 = JavaPairRDD.fromJavaRDD(rdd2);
        JavaPairRDD<Integer, Tuple2<Character, org.apache.spark.api.java.Optional<Character>>> leftOuterJoinRdd = pairRdd1.leftOuterJoin(pairRdd2);
        java.util.Map<Integer, Tuple2<Character, org.apache.spark.api.java.Optional<Character>>> leftOuterJoinMap = leftOuterJoinRdd.collectAsMap();
        Set<Integer> keys2 = leftOuterJoinMap.keySet();
        for (Integer key :
                keys2) {
            System.out.println(key+" : "+leftOuterJoinMap.get(key));
        }

运行结果如下：

在这里插入图片描述

4、rightOuterJoin

对两个 RDD 进行连接操作，类似于sql中的右外连接，存在的话，value用的Some, 不存在用的None，仔细查看比较运行结果
Scala版本

	val conf = new SparkConf().setAppName("rightOuterJoin").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List(("c",2),("b",4),("d",6)))
    val rdd2 = sc.parallelize(List(("b",5),("a",9),("d",2)))
    val right = rdd1.rightOuterJoin(rdd2)
    right.collect.foreach(println)

运行结果如下：

在这里插入图片描述
Java版本

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("rightOuterJoin");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<Tuple2<Integer, Character>> rdd1 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(1, 'a'),
                new Tuple2<Integer, Character>(2, 'b'),
                new Tuple2<Integer, Character>(3, 'c'),
                new Tuple2<Integer, Character>(3, 'd')
        ));
        JavaRDD<Tuple2<Integer, Character>> rdd2 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(2, 'x'),
                new Tuple2<Integer, Character>(3, 'y'),
                new Tuple2<Integer, Character>(4, 'z')
        ));
//转化成PairRDD
        JavaPairRDD<Integer, Character> pairRdd1 = JavaPairRDD.fromJavaRDD(rdd1);
        JavaPairRDD<Integer, Character> pairRdd2 = JavaPairRDD.fromJavaRDD(rdd2);
        JavaPairRDD<Integer, Tuple2<org.apache.spark.api.java.Optional<Character>, Character>> rightOuterJoinRdd = pairRdd1.rightOuterJoin(pairRdd2);
        Map<Integer, Tuple2<Optional<Character>, Character>> rightOuterJoinMap = rightOuterJoinRdd.collectAsMap();
        Set<Integer> keys3 = rightOuterJoinMap.keySet();
        for (Integer key :
                keys3) {
            System.out.println(key+" : "+rightOuterJoinMap.get(key));
        }

运行结果如下：

在这里插入图片描述

5、subtractByKey

类似于 subtrac，删掉 RDD1 中键与 RDD2 中的键相同的元素，仔细查看比较运行结果

Scala版本

    val conf = new SparkConf().setAppName("subtractByKey").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val rdd1 = sc.parallelize(List(("a",6),("c",2),("b",4),("d",6)))
    val rdd2 = sc.parallelize(List(("b",5),("a",9),("d",2)))
    val sub = rdd1.subtractByKey(rdd2)
    sub.collect.foreach(println)

运行结果如下：

在这里插入图片描述

Java版本

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("Sub_Join_Java");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<Tuple2<Integer, Character>> rdd1 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(1, 'a'),
                new Tuple2<Integer, Character>(2, 'b'),
                new Tuple2<Integer, Character>(3, 'c'),
                new Tuple2<Integer, Character>(3, 'd')
        ));
        JavaRDD<Tuple2<Integer, Character>> rdd2 = sc.parallelize(Arrays.asList(
                new Tuple2<Integer, Character>(2, 'x'),
                new Tuple2<Integer, Character>(3, 'y'),
                new Tuple2<Integer, Character>(4, 'z')
        ));
//转化成PairRDD
        JavaPairRDD<Integer, Character> pairRdd1 = JavaPairRDD.fromJavaRDD(rdd1);
        JavaPairRDD<Integer, Character> pairRdd2 = JavaPairRDD.fromJavaRDD(rdd2);
        JavaPairRDD<Integer, Character> subtractByKeyRdd = pairRdd1.subtractByKey(pairRdd2);
        List<Tuple2<Integer, Character>> collect = subtractByKeyRdd.collect();
        for (Tuple2 tp2 :
                collect) {
            System.out.println(tp2._1+" : "+tp2._2);
        }

运行结果如下：

在这里插入图片描述

绿萝蔓蔓绕枝生
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark 算子之join使用
congge_study的博客
04-23 3045
Spark 算子之join使用
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
Spark的RDD操作之Join大全
UncleTian的博客
01-17 1528
一、RDD的Join操作有哪些？ （一）Join：Join类似于SQL的inner join操作，返回结果是前面和后面集合中配对成功的，过滤掉关联不上的。源代码如下： /** Return an RDD containing all pairs of elements with matching keys in this and other. Each pair of elements w...
MySQL：left join 后用 on 还是 where？
最新发布
weixin_45195665的博客
07-09 684
用于返回左表（即LEFT JOIN关键字左边的表）的所有记录，即使在右表中没有匹配的记录。子句中同时指定了连接条件和筛选条件，这样既保证了左表的完整性，又对连接后的结果进行了有效的过滤，只保留了那些有订单的记录。如果我们进一步想在结果中只包括那些至少有一个订单的客户，我们可能会尝试这样写，但这是错误的做法，因为它违背了。（部门表），我们想找出所有员工及其所在的部门名称，即使某些员工没有分配到具体的部门。子句确保了每个客户与他们的订单关联，即使没有订单的客户也会出现在结果集中，其。假设我们有两个表，一个是。
Spark编程之基本的RDD算子之join，rightOuterJoin, leftOuterJoin
stevekangpei的博客
07-24 2990
Spark编程之基本的RDD算子之join，rightOuterJoin, leftOuterJoin 1） 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: RD
7、Spark_RDD算子——Join
weixin_39025328的博客
10-10 233
一、SparkUtils工具类 import org.apache.spark.{SparkConf, SparkContext} object SparkUtils { /** * 默认的master url路径 */ val DEFAULT_MASTER = "local[*]" /** * 默认master为local[*]的获取sparkContext */ def getSparkContext(appName:String):SparkContext
SparkRDD算子--join算子
寒暄的博客
08-03 672
语法 val newRdd = oldRdd. join(otherDataset, [numTasks]) otherDataset表示join的对象 numTasks表示分区数 源码 def join[W](other : org.apache.spark.rdd.RDD[scala.Tuple2[K, W]]) : org.apache.spark.rdd.RDD[scala.Tuple2[K, scala.Tuple2[V, W]]] = { /* compiled code */ } 作用 在类
RDD键值转换操作(4)–cogroup、join
cloud-2014的专栏
09-14 445
cogroup ##参数为1个RDD def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))] def cogroup[W](other: RDD[(K, W)], numPartitions: Int): RDD[(K, (Iterable[V], Iterable[W]))] def
RDD Join 性能调优
01-12 9980
阅读本篇博文时，请先理解RDD的描述及作业调度：[《深入理解Spark 2.1 Core （一）：RDD的原理与源码分析 》]（http://blog.csdn.net/u011239443/article/details/53894611#t16）Join数据是我们在Spark操作中的很重要的一部分。Spark Core 和Spark SQL的基本类型都支持join操作。虽然join很常用而且功能
spark-2.4.7-bin-hadoop2.6.tgz
03-17
1. **弹性分布式数据集（RDD）**：RDD是Spark的基本数据抽象，它是不可变、分区的记录集合，可以在集群中并行操作。RDD提供了高效的转换（transformations）和动作（actions）操作。 2. **内存计算**：Spark通过将...
摸鱼大数据-Spark Core-RDD综合案例-搜狗搜索流
06-23
搜狗搜索流
spark基本算子操作
03-21
### Spark基本算子操作 #### 一、概述 在Spark框架中，为了高效地处理大规模数据，设计了一系列的算子操作。这些算子分为两类：转换（Transformations）和动作（Actions）。转换算子用于创建新的分布式数据集，而...
Java Spark算子：sample
01-07
import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.JavaSparkContext; import java.util.Arrays; import java.util.List; /** * sample(withReplacement,fraction,seed) 算子 * 对RDD...
Spark之join、leftOuterJoin、rightOuterJoin及fullOuterJoin
HarvardFly的博客
10-06 338
Spark之join、leftOuterJoin、rightOuterJoin及fullOuterJoin Spark的join与mysql的join类似，mysql的join是将表与表之间连接查询，spark中join是将RDD数据集进行连接，Spark主要有join、leftOuterJoin、rightOuterJoin及fullOuterJ...
Spark的RDD操作之Join大全！
热门推荐
邓佑权的博客
11-18 5万+
Spark的RDD操作之Join大全！ 一、RDD的Join操作有哪些？ （一）Join：Join类似于SQL的inner join操作，返回结果是前面和后面集合中配对成功的，过滤掉关联不上的。源代码如下： /** * Return an RDD containing all pairs of elements with matching keys in `this`
[Spark] RDD中JOIN的使用
Cindy的博客
07-13 2万+
JOIN在Spark Core中的使用1. inner joininner join，只返回左右都匹配上的// 启动spark-shell，定义两个rdd，做join操作 [hadoop@hadoop01 ~]$ spark-shell --master local[2] scala&gt; val a = sc.parallelize(Array(("A","a1"),("B","b1"),("...
[Spark]Spark RDD的join和cogroup算子示例
weixin_34414196的博客
08-14 130
为什么80%的码农都做不了架构师？>>> ...
Spark RDD JOIN 调优
尼克不可的博客
04-15 2598
Spark RDD JOIN 调优 一、 大表关联小表 1. 小表数据量非常小时 一般当副表的数据比较小时，可以考虑将这部分的小表数据直接加载到内存中，如加工成为一个Map 结构的对象，在使用的时候将这个对象广播到各个Executor中。 在广播时需要注意广播的这个数据集的大小，如果太大就会得不偿失，因为广播的实质其实就是把同一份数据集对象复制多份，然后通过序列化的方式将数据集分发到各个Executor中，所以如果集合太大那么会占用过多的网络带宽和内存。 在使用广播变量的时候还需要注意，如果直接在一个ma
Spark RDD 算子详解：实现原理与执行流程分析
RDD 算子是 Spark 中的一种基本操作单元，用于处理和转换 RDD 数据。下面是 Spark 1.4.1 中一些常用的 RDD 算子和它们的实现原理。 1. take(num: Int)：take 算子用于从 RDD 中取出指定数量的元素。其实现原理是，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值