Spark算子实战action（Java）

1、reduce算子操作

package cn.spark.sparktest;

import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;


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


public class actionOpertion {
    public static void main(String[] args){
        reduce();
    }

    private static void reduce() {
        // 创建SparkConf和JavaSparkContext
        SparkConf conf = new SparkConf()
                .setAppName("reduce")
                .setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 有一个集合，里面有1到10,10个数字，现在要对10个数字进行累加
        List numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        JavaRDD numbers = sc.parallelize(numberList);

        // 使用reduce操作对集合中的数字进行累加
        // reduce操作的原理：
        // 首先将第一个和第二个元素，传入call()方法，进行计算，会获取一个结果，比如1 + 2 = 3
        // 接着将该结果与下一个元素传入call()方法，进行计算，比如3 + 3 = 6
        // 以此类推
        // 所以reduce操作的本质，就是聚合，将多个元素聚合成一个元素

        int  result = numbers.reduce(new Function2() {
            @Override
            public Integer call(Integer i, Integer j) throws Exception {
                return i + j;
            }
        });
        System.out.println(result);
        sc.close();
    }
}

测试

2、collect算子操作

private static void collect(){
    // 创建SparkConf和JavaSparkContext
    SparkConf conf = new SparkConf()
            .setAppName("collect")
            .setMaster("local");
    JavaSparkContext sc = new JavaSparkContext(conf);

    // 有一个集合，里面有1到10,10个数字，现在要对10个数字进行累加
    List numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    JavaRDD numbers = sc.parallelize(numberList);

    // 使用map操作将集合中所有数字乘以2
   JavaRDD result = numbers.map(new Function() {
       @Override
       public Integer call(Integer i) throws Exception {
           return i * 3;
       }
   });

    // 不用foreach action操作，在远程集群上遍历rdd中的元素
    // 而使用collect操作，将分布在远程集群上的doubleNumbers RDD的数据拉取到本地
    // 这种方式，一般不建议使用，因为如果rdd中的数据量比较大的话，比如超过1万条
    // 那么性能会比较差，因为要从远程走大量的网络传输，将数据获取到本地
    // 此外，除了性能差，还可能在rdd中数据量特别大的情况下，发生oom异常，内存溢出
    // 因此，通常，还是推荐使用foreach action操作，来对最终的rdd元素进行处理
    List collectRrsult = result.collect();

    for (Integer i : collectRrsult) System.out.println(i);
}

测试：

3、count算子操作

public static void count(){
     //创建SparkConf和JavaSparkContext
    SparkConf conf = new SparkConf()
            .setAppName("collect")
            .setMaster("local");
    JavaSparkContext sc = new JavaSparkContext(conf);

    // 有一个集合，里面有1到10,10个数字，现在要对10个数字进行累加
    List numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    JavaRDD numbers = sc.parallelize(numberList);

    // 使用map操作将集合中所有数字乘以2
   JavaRDD result = numbers.map(new Function() {
       @Override
       public Integer call(Integer i) throws Exception {
           return i * 3;
       }
   });
   long end = result.count();
   System.out.println(end);
   sc.close();
}

测试：

4、take算子操作

private static void take() {
        // 创建SparkConf和JavaSparkContext
        SparkConf conf = new SparkConf()
                .setAppName("take")
                .setMaster("local");  
        JavaSparkContext sc = new JavaSparkContext(conf);
        
        // 有一个集合，里面有1到10,10个数字，现在要对10个数字进行累加
        List numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        JavaRDD numbers = sc.parallelize(numberList);
        
        // 对rdd使用count操作，统计它有多少个元素
        // take操作，与collect类似，也是从远程集群上，获取rdd的数据
        // 但是collect是获取rdd的所有数据，take只是获取前n个数据
        List top3Numbers = numbers.take(3);
        
        for(Integer num : top3Numbers) {
            System.out.println(num);  
        }
        
        // 关闭JavaSparkContext
        sc.close();
    }

测试：