Spark算子实战transforma（Java）

• map算子：将集合中的每个元素乘2

package cn.spark.sparktest;

import java.util.Arrays;

import java.util.List;

import org.apache.spark.SparkConf;

import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;

import org.apache.spark.api.java.function.Function;

import org.apache.spark.api.java.function.VoidFunction;



/**
 * transformation操作实战
 * @author Administrator
 *
 */

public class transformationOpertion {

    public static void main(String[] args) {
         map();

    }

    /**
     * map算子案例：将集合中每一个元素都乘以2
     */
    private static void map() {
        // 创建SparkConf
        SparkConf conf = new SparkConf()
                .setAppName("map")
                .setMaster("local");
        // 创建JavaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 构造集合
        List numbers = Arrays.asList(1, 2, 3, 4, 5);

        // 并行化集合，创建初始RDD
        JavaRDD numberRDD = sc.parallelize(numbers);
        // 使用map算子，将集合中的每个元素都乘以2
        // map算子，是对任何类型的RDD，都可以调用的
        // 在java中，map算子接收的参数是Function对象
        // 创建的Function对象，一定会让你设置第二个泛型参数，这个泛型类型，就是返回的新元素的类型
        // 同时call()方法的返回类型，也必须与第二个泛型类型同步
        // 在call()方法内部，就可以对原始RDD中的每一个元素进行各种处理和计算，并返回一个新的元素
        // 所有新的元素就会组成一个新的RDD
        JavaRDD pair = numberRDD.map(new Function() {
            @Override
            public Integer call(Integer i) throws Exception {
                return i*2;
            }
        });

        pair.foreach(new VoidFunction() {
            @Override
            public void call(Integer integer) throws Exception {
                System.out.println(integer);
            }
        });
        sc.close();
    }
}

结果为：

• filter算子：过滤出集合中的偶数

package cn.spark.sparktest;

import java.util.Arrays;

import java.util.List;

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.Function;

import org.apache.spark.api.java.function.VoidFunction;



/**
 * transformation操作实战
 * @author Administrator
 *
 */

public class transformationOpertion {

    public static void main(String[] args) {
        // map();
        filter();
    }

   

    public static void filter(){

        // 创建SparkConf
        SparkConf conf = new SparkConf()
                .setAppName("filter")
                .setMaster("local");
        // 创建JavaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 构造集合
        List numbers = Arrays.asList(1, 2, 3, 4, 5,6,7,8,9);

        // 并行化集合，创建初始RDD
        JavaRDD numberRDD = sc.parallelize(numbers);

        JavaRDD evenNum = numberRDD.filter(new Function() {
            @Override
            public Boolean call(Integer i) throws Exception {
                return i % 2 ==0;
            }
        });

        evenNum.foreach(new VoidFunction() {
            @Override
            public void call(Integer integer) throws Exception {
                System.out.println(integer);
            }
        });

        sc.close();
    }
}

测试：

• flatmap：将行拆分为单词

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

    List strs = Arrays.asList("hello spark, hello china","ni hao shij ie ","hello hadoop"
    ,"hello bigdata");

    JavaRDD strsRDD = sc.parallelize(strs);
    //flatmap算子 在Java中接收的参数是FlatMapFunction
    //需要自己定义它的第二个泛型，即  代表了新返回值得类型
    //call方法 返回的类型 不是U 而知Interable 这里的U也与第二个泛型类型相同
    //flatmap其实就是 接收原始RDD中的每一个元素 返回可以返回多个元素
    //封装在Iterable中 可以使用ArrayList等集合
    JavaRDD flat = strsRDD.flatMap(new FlatMapFunction() {
        @Override
        public Iterable call(String s) throws Exception {
            return Arrays.asList(s.split(" "));
        }
    });
    flat.foreach(new VoidFunction() {
        @Override
        public void call(String s) throws Exception {
            System.out.println(s);
        }
    });

    sc.close();
}

测试：

• groupByKey:将每个班级的成绩进行分组

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

        // 模拟集合
        List> scoreList = Arrays.asList(
                new Tuple2("class1", 80),
                new Tuple2("class2", 75),
                new Tuple2("class1", 90),
                new Tuple2("class2", 65));

        JavaPairRDD scorrRDD = sc.parallelizePairs(scoreList);
        //groupByKey算子 返回的是JavaPairRDD
        //但是JavaPairRDD 泛型的第一个返回值不变 第二个为iterable类型
       //也就是说安装key进行了分组 那么每个key可能对应多个value 多个key 聚合成了iterable
    //接下来 使用JavaPairRDD 进行处理
        JavaPairRDD> result = scorrRDD.groupByKey();

        result.foreach(new VoidFunction>>() {
            @Override
            public void call(Tuple2> s) throws Exception {
                System.out.println("class:" + s._1);
                Iterator it = s._2.iterator();
                while (it.hasNext()){
                    System.out.println(it.next());
                }
            }
        });

        sc.close();

    }

}

测试：

• reduceByKey:统计每个班级的总分

 

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

        // 模拟集合
        List> scoreList = Arrays.asList(
                new Tuple2("class1", 80),
                new Tuple2("class2", 75),
                new Tuple2("class1", 90),
                new Tuple2("class2", 65));

        // 并行化集合，创建JavaPairRDD
        JavaPairRDD scores = sc.parallelizePairs(scoreList);
        /*
        * reducebykey 算子接收的参数是Functaion2类型 有三个泛型参数 代表了三个值
        * 第一二个代表了原始RDD元素中value的值的类型
        * 因此会依次将第一二个传入 再将第三个传入
        * 会自动定义两个类型变量 代表call方法传入的类型参数
        *
        * */
        JavaPairRDD result = scores.reduceByKey(new Function2
                () {
            @Override
            public Integer call(Integer i, Integer j) throws Exception {
                return i + j;
            }
        });

        result.foreach(new VoidFunction>() {
            @Override
            public void call(Tuple2 s) throws Exception {
                System.out.println(s);
            }
        });
        sc.close();
    }

}

测试：

• sortByKey:将学生分数进行排序

private static void sortByKey() {
        // 创建SparkConf
        SparkConf conf = new SparkConf()
                .setAppName("sortByKey")  
                .setMaster("local");
        // 创建JavaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);
        
        // 模拟集合
        List> scoreList = Arrays.asList(
                new Tuple2(65, "leo"),
                new Tuple2(50, "tom"),
                new Tuple2(100, "marry"),
                new Tuple2(80, "jack"));
        
        // 并行化集合，创建RDD
        JavaPairRDD scores = sc.parallelizePairs(scoreList);
        
        // 对scores RDD执行sortByKey算子
        // sortByKey其实就是根据key进行排序，可以手动指定升序，或者降序
        // 返回的，还是JavaPairRDD，其中的元素内容，都是和原始的RDD一模一样的
        // 但是就是RDD中的元素的顺序，不同了
        JavaPairRDD sortedScores = scores.sortByKey(false);  
        
        // 打印sortedScored RDD
        sortedScores.foreach(new VoidFunction>() {

            private static final long serialVersionUID = 1L;

            @Override
            public void call(Tuple2 t) throws Exception {
                System.out.println(t._1 + ": " + t._2);  
            }
            
        });
        
        // 关闭JavaSparkContext
        sc.close();
    }

测试：

• join：打印每个学生的成绩

private static void join() {
        // 创建SparkConf
        SparkConf conf = new SparkConf()
                .setAppName("join")  
                .setMaster("local");
        // 创建JavaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);
        
        // 模拟集合
        List> studentList = Arrays.asList(
                new Tuple2(1, "leo"),
                new Tuple2(2, "jack"),
                new Tuple2(3, "tom"));
        
        List> scoreList = Arrays.asList(
                new Tuple2(1, 100),
                new Tuple2(2, 90),
                new Tuple2(3, 60));
        
        // 并行化两个RDD
        JavaPairRDD students = sc.parallelizePairs(studentList);
        JavaPairRDD scores = sc.parallelizePairs(scoreList);
        
        // 使用join算子关联两个RDD
        // join以后，还是会根据key进行join，并返回JavaPairRDD
        // 但是JavaPairRDD的第一个泛型类型，之前两个JavaPairRDD的key的类型，因为是通过key进行join的
        // 第二个泛型类型，是Tuple2的类型，Tuple2的两个泛型分别为原始RDD的value的类型
        // join，就返回的RDD的每一个元素，就是通过key join上的一个pair
        // 什么意思呢？比如有(1, 1) (1, 2) (1, 3)的一个RDD
            // 还有一个(1, 4) (2, 1) (2, 2)的一个RDD
            // join以后，实际上会得到(1 (1, 4)) (1, (2, 4)) (1, (3, 4))
        JavaPairRDD> studentScores = students.join(scores);
        
        // 打印studnetScores RDD
        studentScores.foreach(
                
                new VoidFunction>>() {

                    private static final long serialVersionUID = 1L;
        
                    @Override
                    public void call(Tuple2> t)
                            throws Exception {
                        System.out.println("student id: " + t._1);  
                        System.out.println("student name: " + t._2._1);  
                        System.out.println("student score: " + t._2._2);
                        System.out.println("===============================");   
                    }
                    
                });
        
        // 关闭JavaSparkContext
        sc.close();
    }
    
    /**
     * cogroup案例：打印学生成绩
     */
    private static void cogroup() {
        // 创建SparkConf
        SparkConf conf = new SparkConf()
                .setAppName("cogroup")  
                .setMaster("local");
        // 创建JavaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);
        
        // 模拟集合
        List> studentList = Arrays.asList(
                new Tuple2(1, "leo"),
                new Tuple2(2, "jack"),
                new Tuple2(3, "tom"));
        
        List> scoreList = Arrays.asList(
                new Tuple2(1, 100),
                new Tuple2(2, 90),
                new Tuple2(3, 60),
                new Tuple2(1, 70),
                new Tuple2(2, 80),
                new Tuple2(3, 50));
        
        // 并行化两个RDD
        JavaPairRDD students = sc.parallelizePairs(studentList);
        JavaPairRDD scores = sc.parallelizePairs(scoreList);
        
        // cogroup与join不同
        // 相当于是，一个key join上的所有value，都给放到一个Iterable里面去了
        JavaPairRDD, Iterable>> studentScores =
                students.cogroup(scores);
        
        // 打印studnetScores RDD
        studentScores.foreach(
                
                new VoidFunction,Iterable>>>() {

                    private static final long serialVersionUID = 1L;
        
                    @Override
                    public void call(
                            Tuple2, Iterable>> t)
                            throws Exception {
                        System.out.println("student id: " + t._1);  
                        System.out.println("student name: " + t._2._1);  
                        System.out.println("student score: " + t._2._2);
                        System.out.println("===============================");   
                    }
                    
                });
        
        // 关闭JavaSparkContext
        sc.close();
    }
    
}

 

测试：