spark Java 数据合并的算子（union ，intersection subtract cartesian ）

本文链接：https://blog.youkuaiyun.com/zahuali/article/details/106115931

本文介绍了Spark中的数据合并算子，包括distinct用于去重，union进行数据合并，intersection计算交集，以及subtract求差集。文章特别强调了intersection的性能特点，由于需要网络混洗数据，其效率相对较低。此外，还提到了cartesian算子，用于生成两个RDD的笛卡尔积。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

spark中的常用算子以图中为例

在这里插入图片描述

以下以代码展示

distinct 算子去重

ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(3);


        JavaRDD<Integer> parallelize = sc.parallelize(list);

        JavaRDD<Integer> distinct = parallelize.distinct();//该算中也可以添加参数备注分区数

        List<Integer> collect = distinct.collect();

        for (Integer integer: collect){
            System.out.println(integer);
        }
结果： 
4
1
3
2

union 合并算子

 ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(3);

        ArrayList<Integer> list2 = new ArrayList<Integer>();

        list2.add(2);
        list2.add(5);
        list2.add(6);

        JavaRDD<Integer> parallelize = sc.parallelize(list1);
        JavaRDD<Integer> parallelize1 = sc.parallelize(list2);

        List<Integer> collect = parallelize.union(parallelize1).collect();


        for (Integer integer: collect){
            System.out.println(integer);
        }
结果：
1
2
3
4
3
2
5
6

算子intersection 求集合之间的交集
intersection(other) 方法，只返回两个 RDD 中都有的元素。intersection()
在运行时也会去掉所有重复的元素（单个 RDD 内的重复元素也会一起移除）。尽管
intersection() 与 union() 的概念相似，intersection() 的性能却要差很多，因为它需要
通过网络混洗数据来发现共有的元素

        ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(3);

        ArrayList<Integer> list2 = new ArrayList<Integer>();

        list2.add(2);
        list2.add(5);
        list2.add(6);

        JavaRDD<Integer> parallelize = sc.parallelize(list1);
        JavaRDD<Integer> parallelize1 = sc.parallelize(list2);

        List<Integer> collect = parallelize.intersection(parallelize1).collect();


        for (Integer integer: collect){
            System.out.println(integer);
        }
结果：
2

subtract 算子求以左边算子为基准求交集以外的数据

ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(3);

        ArrayList<Integer> list2 = new ArrayList<Integer>();

        list2.add(2);
        list2.add(5);
        list2.add(6);

        JavaRDD<Integer> parallelize = sc.parallelize(list1);
        JavaRDD<Integer> parallelize1 = sc.parallelize(list2);

        List<Integer> collect = parallelize1.subtract(parallelize).collect();


        for (Integer integer: collect){
            System.out.println(integer);
        }
      
      结果：
      5
      6

算子 cartesian 求笛卡尔积所有的结果都计算上

 ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(3);

        ArrayList<Integer> list2 = new ArrayList<Integer>();

        list2.add(2);
        list2.add(5);
        list2.add(6);

        JavaRDD<Integer> parallelize = sc.parallelize(list1);
        JavaRDD<Integer> parallelize1 = sc.parallelize(list2);

        List<Tuple2<Integer, Integer>> collect = parallelize.cartesian(parallelize1).collect();


        for (Tuple2 integer: collect){
            System.out.println(integer);
        }

结果：
(1,2)
(1,5)
(1,6)
(2,2)
(2,5)
(2,6)
(3,2)
(3,5)
(3,6)
(4,2)
(4,5)
(4,6)
(3,2)
(3,5)
(3,6)