Spark从零到一 （四）Spark API In Java8

                          Spark API In  Java8

一、map、flatMap

map十分容易理解，他是将源JavaRDD的一个一个元素的传入call方法，并经过算法后一个一个的返回从而生成一个新的JavaRDD。

map

• 示例代码

List<Integer> list = Arrays.asList(1, 2, 3);
System.out.println(list.size());
JavaRDD<Integer> listRDD = sc.parallelize(list);

JavaRDD<Integer> nameRDD = listRDD.map(n -> {
	return n * n;
});
nameRDD.foreach(f -> {
	System.out.println("n的平方=" + f);
});

• 运行结果

n的平方=1
n的平方=4
n的平方=9

可以看出，对于map算子，源JavaRDD的每个元素都会进行计算，由于是依次进行传参，所以他是有序的，新RDD的元素顺序与源RDD是相同的。而由有序又引出接下来的flatMap。

 

flatMap

flatMap与map一样，是将RDD中的元素依次的传入call方法，他比map多的功能是能在任何一个传入call方法的元素后面添加任意多元素，而能达到这一点，正是因为其进行传参是依次进行的。

• 示例代码

   List<String> list = Arrays.asList("张无忌 赵敏","宋青书 周芷若");
	        JavaRDD<String> listRDD = sc.parallelize(list);

	        JavaRDD<String> nameRDD = listRDD
	                .flatMap(new FlatMapFunction<String, String>() {
	            @Override
	            public Iterator<String> call(String line) throws Exception {
	                return Arrays.asList(line.split(" ")).iterator();
	            }
	        });
	        nameRDD.foreach(s-> {
	                System.out.println("Hello "+s);
});

• 运行结果

Hello 张无忌
Hello 赵敏
Hello 宋青书
Hello 周芷若

 

二、reduce、reduceByKey

reduce

reduce其实是讲RDD中的所有元素进行合并，当运行call方法时，会传入两个参数，在call方法中将两个参数合并后返回，而这个返回值回合一个新的RDD中的元素再次传入call方法中，继续合并，直到合并到只剩下一个元素时。

• 示例代码

 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        JavaRDD<Integer> listRDD = sc.parallelize(list);

        Integer result = listRDD.reduce((x, y) -> x + y);
        System.out.println(result);
    }

• 运行结果

21

reduceByKey

reduceByKey仅将RDD中所有K,V对中K值相同的V进行合并

• 示例代码

	 List<Tuple2<String, Integer>> list = Arrays.asList(
	                new Tuple2<String, Integer>("武当", 99),
	                new Tuple2<String, Integer>("少林", 97),
	                new Tuple2<String, Integer>("武当", 89),
	                new Tuple2<String, Integer>("少林", 77)
	        );
	        JavaPairRDD<String, Integer> listRDD = sc.parallelizePairs(list);
	        //运行reduceByKey时，会将key值相同的组合在一起做call方法中的操作
	        JavaPairRDD<String, Integer> result = listRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
	            @Override
	            public Integer call(Integer i1, Integer i2) throws Exception {
	                return i1 + i2;
	            }
	        });
	        result.foreach(tuple->{
	           
	                System.out.println("门派: " + tuple._1 + "->" + tuple._2);
	                
	        });

• 运行结果

门派: 少林->174
门派: 武当->188

 

三、union，join和groupByKey 

union，join

当要将两个RDD合并时，便要用到union和join，其中union只是简单的将两个RDD累加起来，可以看做List的addAll方法。就想List中一样，当使用union及join时，必须保证两个RDD的泛型是一致的。

• 示例代码

 final List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
        final List<Integer> list2 = Arrays.asList(3, 4, 5, 6);
        final JavaRDD<Integer> rdd1 = sc.parallelize(list1);
        final JavaRDD<Integer> rdd2 = sc.parallelize(list2);

        rdd1.union(rdd2).foreach(num -> System.out.println(num));

• 运行结果

1
2
3
4
10:08:48.974 [Executor task launch worker for task 0] INFO  org.apache.spark.executor.Executor - Finished task 0.0 in stage 0.0 (TID 0). 751 bytes result sent to driver
10:08:48.977 [dispatcher-event-loop-2] INFO  org.apache.spark.scheduler.TaskSetManager - Starting task 1.0 in stage 0.0 (TID 1, localhost, executor driver, partition 1, PROCESS_LOCAL, 4976 bytes)
10:08:48.977 [Executor task launch worker for task 1] INFO  org.apache.spark.executor.Executor - Running task 1.0 in stage 0.0 (TID 1)
3
4
5
6

groupByKey

union只是将两个RDD简单的累加在一起，而join则不一样，join类似于hadoop中的combin操作，只是少了排序这一段，再说join之前说说groupByKey，因为join可以理解为union与groupByKey的结合：groupBy是将RDD中的元素进行分组，组名是call方法中的返回值，而顾名思义groupByKey是将PairRDD中拥有相同key值得元素归为一组。即：

• 示例代码

 List<Tuple2<String,String>> list = Arrays.asList(
                new Tuple2("武当", "张三丰"),
                new Tuple2("峨眉", "灭绝师太"),
                new Tuple2("武当", "宋青书"),
                new Tuple2("峨眉", "周芷若")
        );
        JavaPairRDD<String, String> listRDD = sc.parallelizePairs(list);

        JavaPairRDD<String, Iterable<String>> groupByKeyRDD = listRDD.groupByKey();
        groupByKeyRDD.foreach(tuple -> {
            String menpai = tuple._1;
            Iterator<String> iterator = tuple._2.iterator();
            String people = "";
            while (iterator.hasNext()){
                people = people + iterator.next()+" ";
            }
            System.out.println("门派:"+menpai + "人员:"+people);
        });

• 运行结果

门派:峨眉人员:灭绝师太 周芷若 
门派:武当人员:张三丰 宋青书

 

join

join是将两个PairRDD合并，并将有相同key的元素分为一组，可以理解为groupByKey和Union的结合

• 示例代码

 final List<Tuple2<Integer, String>> names = Arrays.asList(
                new Tuple2<Integer, String>(1, "东方不败"),
                new Tuple2<Integer, String>(2, "令狐冲"),
                new Tuple2<Integer, String>(3, "林平之")
        );
        final List<Tuple2<Integer, Integer>> scores = Arrays.asList(
                new Tuple2<Integer, Integer>(1, 99),
                new Tuple2<Integer, Integer>(2, 98),
                new Tuple2<Integer, Integer>(3, 97)
        );

        final JavaPairRDD<Integer, String> nemesrdd = sc.parallelizePairs(names);
        final JavaPairRDD<Integer, Integer> scoresrdd = sc.parallelizePairs(scores);

        final JavaPairRDD<Integer, Tuple2<String, Integer>> joinRDD = nemesrdd.join(scoresrdd);
        joinRDD.foreach(tuple -> System.out.println("学号:"+tuple._1+" 姓名:"+tuple._2._1+" 成绩:"+tuple._2._2));
    }

• 运行结果

学号:1 姓名:东方不败 成绩:99
学号:3 姓名:林平之 成绩:97
学号:2 姓名:令狐冲 成绩:98

五、filter、distinct

filter

• 示例代码

 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
	        JavaRDD<Integer> listRDD = sc.parallelize(list);
	        JavaRDD<Integer> filterRDD = listRDD.filter(num -> num % 2 ==0);
	        filterRDD.foreach(num -> System.out.println("num=="+num ));

• 运行结果

num==2
num==4
num==6
num==8

 

distinct

• 示例代码

 List<Integer> list = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5);
        JavaRDD<Integer> listRDD  = (JavaRDD<Integer>) sc.parallelize(list);
        listRDD.distinct().foreach(num -> System.out.println(num));

• 运行结果

num==4
num==1
num==3
num==5
num==2