大数据——Spark RDD算子（三）distinct、union、intersection、subtract、cartesian

最新推荐文章于 2024-05-21 21:41:07 发布
最新推荐文章于 2024-05-21 21:41:07 发布
阅读量500 收藏 2
点赞数
文章标签： spark 大数据 scala java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsjia2970727/article/details/109518239
版权

Spark RDD算子（三）distinct、union、intersection、subtract、cartesian

distinct

  • distinct用于去重，生成的RDD可能有重复的元素，使用distinct方法可以去除重复的元素，不过此方法涉及混洗，操作开销很大

Scala版本

package nj.zb.sparkstu

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

object DistinctScala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("distinctscala")
    val sc = new SparkContext(conf)
    val distinctRdd = sc.makeRDD(List("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd"))
    val a=distinctRdd.distinct()
    a.collect.foreach(println)
  }
}

结果展示：
在这里插入图片描述

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class DistinctJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("distinctJava");
        JavaSparkContext sc = new JavaSparkContext(conf);
        List<String> strings = Arrays.asList("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd");

        //distinct
        JavaRDD<String> strRdd = sc.parallelize(strings);
        JavaRDD<String> distinctRdd = strRdd.distinct();
        List<String> collect = distinctRdd.collect();
        for (String str :
                collect) {
            System.out.println(str);
        }
        }
}

结果展示：在这里插入图片描述

union

  • RDD1.union(RDD2)用于两个RDD进行合并

Scala版本

package nj.zb.sparkstu

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

object DistinctScala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("distinctscala")
    val sc = new SparkContext(conf)
    val distinctRdd = sc.makeRDD(List("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd"))
    val unionRdd=sc.makeRDD(List("aa","bb","cc"))
    val b=unionRdd.union(distinctRdd)
    b.collect.foreach(println)
  }
}

结果展示：在这里插入图片描述

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class DistinctJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("distinctJava");
        JavaSparkContext sc = new JavaSparkContext(conf);
        List<String> strings = Arrays.asList("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd");
        JavaRDD<String> strRdd = sc.parallelize(strings);
        //union
            List<String> strings1 = new ArrayList<String>();
            strings1.add("aa");
            strings1.add("bb");
            strings1.add("cc");
            JavaRDD<String> strRdd2 = sc.parallelize(strings1);
            JavaRDD<String> unionRdd = strRdd.union(strRdd2);
        List<String> collect = unionRdd.collect();
        for (String str :
                collect) {
            System.out.println(str);
        }
        }
}

结果展示：在这里插入图片描述

intersection

  • RDD1.intersection(RDD2)返回两个RDD的交集，并且去重
  • intersection需要混洗数据，比较浪费性能

Scala版本

package nj.zb.sparkstu

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

object DistinctScala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("distinctscala")
    val sc = new SparkContext(conf)
    val distinctRdd = sc.makeRDD(List("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd"))
    val unionRdd=sc.makeRDD(List("aa","bb","cc"))
    val c=unionRdd.intersection(distinctRdd)
    c.collect.foreach(println)
  }
}

结果展示：在这里插入图片描述

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class DistinctJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("distinctJava");
        JavaSparkContext sc = new JavaSparkContext(conf);
        List<String> strings = Arrays.asList("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd");
        JavaRDD<String> strRdd = sc.parallelize(strings);
        List<String> strings1 = new ArrayList<String>();
            strings1.add("aa");
            strings1.add("bb");
            strings1.add("cc");
            JavaRDD<String> strRdd2 = sc.parallelize(strings1);
            JavaRDD<String> intersectionRdd = strRdd.intersection(strRdd2);
            List<String> collect = intersectionRdd.collect();
        for (String str :
                collect) {
            System.out.println(str);
        }
        }
}

结果展示：在这里插入图片描述

subtract

  • RDD1.subtract(RDD2)返回在RDD1中出现，但是不在RDD2中出现的元素，不去重

Scala版本

package nj.zb.sparkstu

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

object DistinctScala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("distinctscala")
    val sc = new SparkContext(conf)
    val distinctRdd = sc.makeRDD(List("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd"))
    val unionRdd=sc.makeRDD(List("aa","bb","cc"))
    val d=distinctRdd.subtract(unionRdd)
    d.collect.foreach(println)
  }
}

结果展示：
在这里插入图片描述

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class DistinctJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("distinctJava");
        JavaSparkContext sc = new JavaSparkContext(conf);
        List<String> strings = Arrays.asList("aa", "bb", "aa", "bb", "cc", "cc", "dd", "dd");
        JavaRDD<String> strRdd = sc.parallelize(strings);
        List<String> strings1 = new ArrayList<String>();
            strings1.add("aa");
            strings1.add("bb");
            strings1.add("cc");
            JavaRDD<String> strRdd2 = sc.parallelize(strings1);
            JavaRDD<String> subtractRdd = strRdd.subtract(strRdd2);
        List<String> collect = subtractRdd.collect();
        for (String str :
                collect) {
            System.out.println(str);
        }
        }
}

结果展示：在这里插入图片描述

cartesian

  • RDD1.cartesian(RDD2)返回RDD1和RDD2的笛卡尔积，这个开销超级大，慎用

Scala版本

package nj.zb.sparkstu

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

object DistinctScala {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("distinctscala")
    val sc = new SparkContext(conf)
    val rdd1=sc.makeRDD(List("1","2","3"))
    val rdd2=sc.makeRDD(List("a","b","c"))
    val e=rdd1.cartesian(rdd2)
    e.collect.foreach(println)
  }
}

结果展示：
在这里插入图片描述

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class DistinctJava {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("distinctJava");
        JavaSparkContext sc = new JavaSparkContext(conf);
        //cartesian
            JavaRDD<String> rdd1 = sc.parallelize(Arrays.asList("1", "2", "3"));
            JavaRDD<String> rdd2 = sc.parallelize(Arrays.asList("a", "b", "c"));
            JavaPairRDD<String, String> cartesianRdd = rdd1.cartesian(rdd2);
            List<Tuple2<String, String>> collect = cartesianRdd.collect();
        for (Tuple2 tp2 :
                collect) {
            System.out.println(tp2);
        }
        }
    }

结果展示：
在这里插入图片描述

蜂蜜柚子加苦茶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
spark rdd根据某一列去重
热门推荐
u011011025的专栏
12-29 1万+
比如一个rdd有两列 name age name有重复的，现在要根据name来去重 m = rdd.map(lambda r:(r[0],r)) r = m.reduceByKey(lambda x,y:x)首先先生成一个以该列为标准去重的key,该行为value,然后调用reduceByKey就可以啦
Spark RDD distinct 算子
BITDDD小栈
05-29 2408
一.引言 使用spark很久第一次用到 distinct 算子，趁热打铁熟悉一下 distinct 的操作。 二.源码
Spark rdd之distinct
南风知我意
09-22 482
类似于wordcount的写法：map算子把元素转为一个带有null的元组；使用reducebykey对具有相同key的元素进行统计；之后再使用map算子，取得元组中的单词元素，实现去重的效果。
SparkRDD算子--distinct算子
寒暄的博客
07-31 1381
语法 val newRdd = oldRdd.distinct([numTasks]) numTasks表示并行度。 源码 def distinct(numPartitions : scala.Int)(implicit ord : scala.Ordering[T] = { /* compiled code */ }) : org.apache.spark.rdd.RDD[T] = { /* compiled code */ } 作用 对源RDD进行去重后返回一个新的RDD。默认情况下，只有8个并行任务
Spark:distinct算子
weixin_48109576的博客
08-09 750
distinct是Tranformation算子,具有shuffle 功能:去重 源码 分区取设定分区或者按照核数 将rdd用map变为对偶元组,然后用reduceBykey, 我的理解为:reduceBykey是将key建返回,value取出第一个就不叠加了,局部聚合和全局聚合都用这一个函数 在用map取出key 代码实现 object DistinctDemo { def main(args: Array[String]): Unit = { val con...
5、Spark_RDD算子——Union
weixin_39025328的博客
10-10 308
一、SparkUtils工具类 import org.apache.spark.{SparkConf, SparkContext} object SparkUtils { /** * 默认的master url路径 */ val DEFAULT_MASTER = "local[*]" /** * 默认master为local[*]的获取sparkContext */ def getSparkContext(appName:String):SparkContext
Python学习笔记——大数据之Spark简介与环境搭建
02-24
Spark是Apache顶级项目里面最火的大数据处理的计算引擎，它目前是负责大数据计算的工作。包括离线计算或交互式查询、数据挖掘算法、流式计算以及图计算等。核心组件如下：SparkCore：包含Spark的基本功能；尤其是...
Python学习笔记——大数据之SPARK核心
02-24
RDD（ResilientDistributedDatasets弹性分布式数据集），是spark中最重要的概念，可以简单的把RDD理解成一个提供了许多操作接口的数据集合，和一般数据集不同的是，其实际数据分布存储于一批机器中（内存或磁盘中）...
Spark Transformation —— distinct 算子
搬砖小工053
07-22 3886
distinct对RDD中的元素进行去重操作。代码测试测试数据准备在hdfs上放一个文件1.txt 打开spark-shellspark-shell --master spark://master:7077(重要的事情说多遍，spark-shell和spark-submit核心的参数是差不多的)创建RDDvar data = sc.textFile("/qgzang/1.txt") 测试di
Flink大数据实时计算系列-Flink的union算子用法
段智华的博客
06-14 1138
Flink的union算子用法 目录 Flink函数简介Flink union函数案例实战文件数据源fakfa数据源union算子操作union测试结果Flink系列博客 Flink函数简介 Flink函数包括：flatmap、rich function、operators算子（connect与union） Flink union函数案例实战 文件数据源 package com.flinkniu.flink.source; import com.sun.org.apache.xpath.intern
spark RDD算子（三）distinct、union、intersection、subtract、cartesian
qq_40333693的博客
11-11 547
spark伪集合 尽管RDD本身不是严格意义上的集合，但它也支持许多数学上的集合操作，比如合并和相交操作 distinct distinct用于去重，我们生成的RDD可能有重复元素，使用distinct方法可以去掉重读的元素，不过此方法涉及到混洗，操作开销很大 scala版本： val RDD = sc.parallelize(List("aa", "aa", "bb", "cc", "dd")) val distinctRDD = RDD.collect() distinctRDD.foreach(pri
SparkRDD算子--intersection算子
寒暄的博客
08-01 449
语法 val newRdd = oldRdd1.intersection(oldRdd2) 源码 def intersection(other : org.apache.spark.rdd.RDD[T]) : org.apache.spark.rdd.RDD[T] = { /* compiled code */ } 作用 计算两个RDD的交集。 例子 package com.day1 import org.apache.spark.rdd.RDD import org.apache.spark.{Spa
【RDD Transformation】union、intersection、distinct、join
hyj
08-09 206
一、Rdd转化算子 1、【union】并集； 2、【intersection】交集； 3、【distinct】去重； 4、【join】只对相同的key合并操作； 二、实例 package com.cn.rddOperator import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} object Transformation02 { def main(args: Array[Str
spark简单使用——union intersection subtract cartesian
archer的技术故事
01-03 1063
spark简单使用——union intersection subtract cartesian 本文主要参考：OReilly Learning Spark 首先看一下书中的说明： 下面是我在sprark中进行操作的截图：
spark RDD基础装换操作--distinct操作
weixin_43744732的博客
01-29 1728
4.distinct操作 将RDD中用户数据按照“姓名”去重。 scala> val rddData = sc.parallelize(Array(“Alice”,“Nick”,“Alice”,“Kotlin”,“Catalina”,“Catalina”),3) rddData: org.apache.spark.rdd.RDD[String] = ParallelCollectionRD...
spark RDD基础装换操作--intersection操作
weixin_43744732的博客
01-29 569
8.intersection操作 对包含数字1，1，2的RDD与包含数字2，2，3的RDD进行交集运算。 scala> val rddData1 = sc.parallelize(Array(1,1,2)) rddData1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[5] at parallelize at <con...
Spark算子：RDD基本转换操作(4)–union、intersection、subtract
Rocky
12-27 7085
关键字：Spark算子、Spark RDD基本转换、union、intersection、subtract union def union(other: RDD[T]): RDD[T] 该函数比较简单，就是将两个RDD进行合并，不去重。   scala> var rdd1 = sc.makeRDD(1 to 2,1)rdd1: org.apache.spark.rdd.RDD[Int]
Spark搭建 Standalone模式详细步骤
最新发布
weixin_52134189的博客
05-21 694
Spark搭建 Standalone模式详细步骤
sparkrdd算子
03-18
Spark RDD（弹性分布式数据集）是Spark中最基本的数据抽象，它代表了一个不可变、可分区、可并行计算的数据集合。RDD提供了一系列的算子（操作符）来进行数据的转换和计算。下面是一些常用的Spark RDD算子介绍： 1....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值