Spark RDD（五）groupByKey，cogroup，subtractByKey，join，leftOuterJoin，rightOuterJoin

最新推荐文章于 2022-12-02 16:52:30 发布
最新推荐文章于 2022-12-02 16:52:30 发布
阅读量336 收藏
点赞数
分类专栏： Spark 文章标签： spark scala RDD
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiandanbuguo/article/details/109611391
版权

Spark RDD（五）

groupByKey

groupByKey会将RDD[key,value] 按照相同的key进行分组，形成RDD[key,Iterable[value]]的形式

scala版本

val rdd1 = sc.parallelize(List(("a", 97),("a", 87),("b", 99),("b", 97),("c", 100)))
val groupByKeyRDD = rdd1.groupByKey()
groupByKeyRDD.collect.foreach(println)

在这里插入图片描述

java版本

JavaRDD<Tuple2<String, Integer>> rdd1 = sc.parallelize(Arrays.asList(
       new Tuple2<>("a", 1),
       new Tuple2<>("a", 11),
       new Tuple2<>("a", 3),
       new Tuple2<>("b", 5),
       new Tuple2<>("b", 2),
       new Tuple2<>("d", 3),
       new Tuple2<>("c", 9)
));
//将JavaRDD<Tuple2<String,Integer>> 类型转换为 JavaPairRDD<String, Integer>
JavaPairRDD<String, Integer> pairRDD1 = JavaPairRDD.fromJavaRDD(rdd1);
JavaPairRDD<String, Iterable<Integer>> groupByKeyRDD = pairRDD1.groupByKey();
List<Tuple2<String, Iterable<Integer>>> collect = groupByKeyRDD.collect();
for (Tuple2<String, Iterable<Integer>> s : collect) {
   System.out.println(s);
}

在这里插入图片描述

cogroup

对两个RDD中的<k,v>元素，每个RDD中相同key中的元素分别聚合成一个集合

scala版本

  • rdd1.cogroup(rdd2)会将rdd1和edd2按照相同的key进行分组，得到(key,RDD[key,Iterable[value1],Iterable[value2]])的形式
  • cogroup也可以多个进行分组
val rdd1 = sc.parallelize(List(("a",1),("a",11),("b",5),("b",2),("c",9)))
val rdd2 = sc.parallelize(List(("b",15),("b",2),("d",13),("c",4)))
val rdd3 = sc.parallelize(List(("a",85),("b",45),("d",33),("c",99)))

val pairRDD1 = JavaPairRDD.fromJavaRDD(rdd1)
val pairRDD2 = JavaPairRDD.fromJavaRDD(rdd2)
val pairRDD3 = JavaPairRDD.fromJavaRDD(rdd3)
val Rdd1CoRdd2 = rdd1.cogroup(rdd2)
val Rdd1CoRdd2CoRdd3 = rdd1.cogroup(rdd2,rdd3)
println("--------rdd1 cogroup rdd2------")
Rdd1CoRdd2.collect.foreach(println)
println("------rdd1 cogroup (rdd2,rdd3)------ ")
Rdd1CoRdd2CoRdd3.collect.foreach(println)

在这里插入图片描述

java版本

JavaRDD<Tuple2<String, Float>> rdd1 = sc.parallelize(Arrays.asList(
        new Tuple2<String, Float>("a", 11f),
        new Tuple2<String, Float>("a", 111f),
        new Tuple2<String, Float>("b", 11f),
        new Tuple2<String, Float>("c", 11f)
));
JavaRDD<Tuple2<String, Float>> rdd2 = sc.parallelize(Arrays.asList(
        new Tuple2<String, Float>("b", 21f),
        new Tuple2<String, Float>("c", 11f),
        new Tuple2<String, Float>("d", 21f),
        new Tuple2<String, Float>("b", 21f)
));
JavaRDD<Tuple2<String, Float>> rdd3 = sc.parallelize(Arrays.asList(
        new Tuple2<String, Float>("a", 31f),
        new Tuple2<String, Float>("b", 31f),
        new Tuple2<String, Float>("d", 31f),
        new Tuple2<String, Float>("a", 31f)
));
JavaPairRDD<String, Float> rdd1Pair = JavaPairRDD.fromJavaRDD(rdd1);
JavaPairRDD<String, Float> rdd2Pair = JavaPairRDD.fromJavaRDD(rdd2);
JavaPairRDD<String, Float> rdd3Pair = JavaPairRDD.fromJavaRDD(rdd3);

JavaPairRDD<String, Tuple2<Iterable<Float>, Iterable<Float>>> cogroup = rdd1Pair.cogroup(rdd2Pair);
List<Tuple2<String, Tuple2<Iterable<Float>, Iterable<Float>>>> collect = cogroup.collect();
for (Tuple2<String, Tuple2<Iterable<Float>, Iterable<Float>>> stringTuple2Tuple2 : collect) {
    System.out.println(stringTuple2Tuple2);
}

在这里插入图片描述

subtractByKey

subtractByKey和基本转换操作中的subtract类似，只不过这里是针对K的，返回在主RDD中出现，并且不在otherRDD中出现的元素

scala版本

val rdd1 = sc.parallelize(List("a","b","c","d")).map((_,1))
val rdd2 = sc.parallelize(List("b","c","e","f")).map((_,1))
rdd1.subtractByKey(rdd2).collect.foreach(println)

在这里插入图片描述

java版本

JavaRDD<String> rdd1 = sc.parallelize(Arrays.asList("a", "b", "c","d"));
JavaRDD<String> rdd2 = sc.parallelize(Arrays.asList("c", "c","e", "f", "b"));
JavaPairRDD<String, Integer> pairRDD1 = rdd1.mapToPair(new PairFunction<String, String, Integer>() {
    @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
        return new Tuple2<>(s, 1);
    }
});

JavaPairRDD<String, Integer> pairRDD2 = rdd2.mapToPair(new PairFunction<String, String, Integer>() {
    @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
        return new Tuple2<>(s, 1);
    }
});

JavaPairRDD<String, Integer> subtractByKeyRDD = pairRDD1.subtractByKey(pairRDD2);
List<Tuple2<String, Integer>> collect3 = subtractByKeyRDD.collect();
System.out.println("------subtractByKeyRDD------");
for (Tuple2<String, Integer> t : collect3) {
    System.out.println(t);
}

在这里插入图片描述

join

内连接，用于将两个key相同的rdd关联起来，与mysql中的join类似

scala版本

// 转换成pairRDD
val rdd1 = sc.parallelize(List("a","b","c")).map((_,1))
val rdd2 = sc.parallelize(List("c","c","d","e","f","b")).map((_,1))
rdd.join(rdd4).collect.foreach(println)

在这里插入图片描述

java版本

JavaRDD<String> rdd1 = sc.parallelize(Arrays.asList("a", "b", "c"));
JavaRDD<String> rdd2 = sc.parallelize(Arrays.asList("c", "c", "d", "e", "f", "b"));
// 将rdd转换成pairRDD
JavaPairRDD<String, Integer> pairRDD1 = rdd1.mapToPair(new PairFunction<String, String, Integer>() {
    @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
        return new Tuple2<>(s, 1);
    }
});

JavaPairRDD<String, Integer> pairRDD2 = rdd2.mapToPair(new PairFunction<String, String, Integer>() {
    @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
        return new Tuple2<>(s, 1);
    }
});
JavaPairRDD<String, Tuple2<Integer, Integer>> joinRDD = pairRDD1.join(pairRDD2);
List<Tuple2<String, Tuple2<Integer, Integer>>> collect = joinRDD.collect();
for (Tuple2<String, Tuple2<Integer, Integer>> t : collect) {
    System.out.println(t);
}

在这里插入图片描述

leftOuterjoin及rightOuterJoin

左外连接和右外连接。左外连接以左表为基准，会将左表元素全部罗列，右表返回option值；右外连接以右表为基准，会将右表元素全部罗列，左表返回option值

scala版本

val rdd1 = sc.parallelize(List("a","b","c")).map((_,1))
val rdd2 = sc.parallelize(List("c","c","d","e","f","b")).map((_,1))
println("----------leftOuterJoin------------")
rdd1.leftOuterJoin(rdd2).collect.foreach(println)
println("----------rightOuterJoin------------")
rdd1.rightOuterJoin(rdd2).collect.foreach(println)

在这里插入图片描述

java版本

JavaRDD<String> rdd1 = sc.parallelize(Arrays.asList("a", "b", "c"));
JavaRDD<String> rdd2 = sc.parallelize(Arrays.asList("c", "c", "d", "e", "f", "b"));
JavaPairRDD<String, Integer> pairRDD1 = rdd1.mapToPair(new PairFunction<String, String, Integer>() {
    @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
        return new Tuple2<>(s, 1);
    }
});

JavaPairRDD<String, Integer> pairRDD2 = rdd2.mapToPair(new PairFunction<String, String, Integer>() {
    @Override
    public Tuple2<String, Integer> call(String s) throws Exception {
        return new Tuple2<>(s, 1);
    }
});
JavaPairRDD<String, Tuple2<Integer, Optional<Integer>>> leftOuterJoinRDD = pairRDD1.leftOuterJoin(pairRDD1);
List<Tuple2<String, Tuple2<Integer, Optional<Integer>>>> collect = leftOuterJoinRDD.collect();
System.out.println("------leftOuterJoin------");
for (Tuple2<String, Tuple2<Integer, Optional<Integer>>> t :collect){
    System.out.println(t);
}

JavaPairRDD<String, Tuple2<Optional<Integer>, Integer>> rightOuterJoinRDD = pairRDD1.rightOuterJoin(pairRDD2);
List<Tuple2<String, Tuple2<Optional<Integer>, Integer>>> collect2 = rightOuterJoinRDD.collect();
System.out.println("------rightOuterJoin------");
for (Tuple2<String, Tuple2<Optional<Integer>, Integer>> t : collect2) {
    System.out.println(t);
}

在这里插入图片描述

简单不过l
关注
专栏目录
sparkRDD函数大全
02-28
spark rdd函数大全。spark rdd操作为core操作，虽然后续版本主要以dataset来操作，但是rdd操作也是不可忽略的一部分。
Spark算子——RDD键值转换操作–leftOuterJoin、rightOuterJoin、subtractByKey
helloxiaozhe的博客
12-08 748
Spark算子——RDD键值转换操作–leftOuterJoin、rightOuterJoin、subtractByKey 一、leftOuterJoin def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))] def leftOuterJoin[W](other: RDD[(K, W)], numPartiti...
Spark的join聚合操作
longwenyanlan的博客
01-07 374
使用场景: join必须作用于 RDD[K,V] 类型的数据,相当于SQL中的内关联join，只返回两个RDD根据K可以关联上的结果 在类型为（K,V)和（K,W)类型的数据集上调用时，返回一个相同key对应的所有元素对在一起的(K, (V, W))数据集,只返回根据key可以关联上的数据，关联不上的， 直接舍去了 示例: [K,V] join[K,W] 返回值类型[K,(V,W)] ...
Spark RDD算子(八) subtractByKey、 join、rightOuterJoin、leftOuterJoin
timicai的博客
11-11 460
目录一、subtractByKey二、 join三、rightOuterJoin四、leftOuterJoin 一、subtractByKey 类似于subtract，删掉 rdd 中键与 rdd2 中的键相同的元素 二、 join 可以把rdd，rdd2中的相同的key给连接起来，类似于sql中的join操作 三、rightOuterJoin 对两个 rdd 进行连接操作，类似于sql中的右外连接，存在的话，value用的Some, 不存在用的None,具体的看上面的图和下面的代码即可 四、leftOut
spark常用RDD算子 - groupByKey
小哇
08-02 1774
def groupByKey(): RDD[(K, Iterable[V])] def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])] def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])] groupByKey会将RDD[key,value] 按照相同的key进行分组，形成RDD[key,Iterable[value]]的形式， 有点类似于sql中的groupby，例如类
Spark算子[16]：subtractByKey、join、rightOuterJoin、leftOuterJoin 实例详解
行走的树
12-16 1197
subtractByKeydef 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 su
Spark RDD是什么？
01-07
Spark 的核心是建立在统一的抽象弹性分布式数据集（Resiliennt Distributed Datasets，RDD）之上的，这使得 Spark 的各个组件可以无缝地进行集成，能够在同一个应用程序中完成大数据处理。本节将对 RDD 的基本概念及...
Spark思维导图之Spark RDD.png
06-11
Spark思维导图之Spark RDD.png
基于Scala的Spark RDD、Spark SQL、Spark Streaming相关Demo设计源码
最新发布
03-28
这是一个基于Scala语言开发的Spark RDD、Spark SQL、Spark Streaming相关Demo，包含35个文件。主要文件类型包括29个Scala源文件、2个Markdown文档、1个Reduced文件、1个XML文件、1个Java源文件和1个TXT文件。该项目...
spark rdd之groupByKey
南风知我意
10-24 1060
GroupByKey操作可能非常昂贵。如果您正在分组以便对每个键执行聚合（例如求和或平均），则使用 `aggregateByKey` 或` reduceByKey` 将提供更好的性能。 >注意：按照目前的实现，groupByKey 必须能够保存内存中任何键的所有键值对。如果一个键的值太多，造成数据倾斜，可能会导致 `OutOfMemoryError`
spark RDD算子（八）之键值对关联操作 subtractByKey, join,fullOuterJoin, rightOuterJoin, leftOuterJoin
qianchun22的博客
11-10 271
章节目录一、subtractByKey二、join三、fullOuterJoin四、leftOuterJoin五、RightOuterJoin代码示例Scala版本Java版本 一、subtractByKey 函数定义 def subtractByKey[W](other: RDD[(K, W)])(implicit arg0: ClassTag[W]): RDD[(K, V)] def subtractByKey[W](other: RDD[(K, W)], numPartitions: Int)(im
7 spark入门键值对操作subtractByKey, join, rightOuterJoin, leftOuterJoin
tianyaleixiaowu的专栏
04-19 2471
转账自：https://blog.csdn.net/t1dmzks/article/details/70557249subtractByKey函数定义def subtractByKey[W](other: RDD[(K, W)])(implicit arg0: ClassTag[W]): RDD[(K, V)] def subtractByKey[W](other: RDD[(K, W)], n...
spark常用RDD算子 - 键值对关联操作 subtractByKey, join,fullOuterJoin, rightOuterJoin, leftOuterJoin
小哇
08-03 343
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: Part
Spark rdd之groupByKey & reduceByKey 区别
南风知我意
05-22 1100
groupByKey 和 reduceByKey 有什么区别？ 从这两个算子的字面意思来看，groupByKey 是先按照 key 进行分组，然后把相同的 key 收集到一起；reduceByKey( f )，把相同的 key 进行聚合，聚合的逻辑由传入 f 函数所指定。 这两个算子，只针对 kv 格式的 RDD 才能使用。在前几篇文章中说了，每调一个算子，都是一次 RDD 的转换，也是一次数据形态的转换。 既然有 RDD 的转换，那么就会有数据依赖形成。下面分别来看看它们所形成的数据依赖图。 1 redu
Hadoop大数据开发零基础实战
01-12
2022最新课程，本课程适合在校大学生、大数据从业人员以及期望通过学习大数据跻身IT行业的人员，学习本课程需要具备一定的Java语言编程基础。课程特色：以Hadoop生态和Spark生态系统为基础，围绕Hadoop对Zookeeper、Flume、Kafka等众多组件框架进行了深入讲解，从安装到底层原理，由浅入深，每个框架均配置有多个实战需求，最后通过案例实战，带领学员对大数据的实际应用有更深层次的理解和思考。Spark生态课程从大数据重要的语言基础Scala讲起，并对重要框架Spark进行了深入讲解，内容包括Spark框架的基本使用以及案例分析。采用最新的架构体系，对案例中可能涉及的普遍需求和疑难需求进行了详细讲解，能广泛适配大部分企业的大数据处理系统。掌握能力：掌握Hadoop研发能力、掌握离线数据存储和分析、掌握离线和实时数据的处理能力、Spark处理数据能力、高性能计算任务编写能力。胜任职位：Hadoop研发工程师、ETL工程师、数据仓库工程师、离线分析工程师、Spark实时处理工程师。
Spark Sql Left Join(多对多)导致的数据膨胀问题和解决
lilyjoke的专栏
03-03 5806
问题：大表left join小表，小表有10万条，大概就10M大小。大表有30多亿条，对应分区下有40个HDFS文件，简单的一个left join，跑了几个小时跑不出结果。 INSERT OVERWRITE TABLE 结果表 PARTITION(dt='20220302') select vertice,types,nvl(dstgid,groupid) as gid from ( select vertice,groupid,types from
Spark算子：RDD键值转换操作(3)–groupByKey、reduceByKey、reduceByKeyLocally
羽翼天宇
08-01 383
Spark算子：RDD键值转换操作(3)–groupByKey、reduceByKey、reduceByKeyLocally 关键字：Spark算子、Spark RDD键值转换、groupByKey、reduceByKey、reduceByKeyLocally groupByKey def groupByKey(): RDD[(K, Iterable[V])] def groupByKey(...
CoGroup实现inner join 和 left join
大秒哥的博客
12-02 220
通过coGroup方式来时间内联和左关联。
leftOuterJoin和rightOuterJoin
06-06
leftOuterJoin 和 rightOuterJoin 是 Spark 中两种常用的连接操作，它们分别表示左外连接和右外连接。 leftOuterJoin 操作会将左侧的 RDD 中的每个键都保留下来，并将右侧的 RDD 中与之对应的键的值与之连接。如果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值