【spark core学习---算子总结(java版本) (第1部分)】

• map算子
• flatMap算子
• mapParitions算子
• filter算子
• mapParttionsWithIndex算子
• sample算子
• distinct算子
• groupByKey算子
• reduceByKey算子

1、map算子

（1）任何类型的RDD都可以调用map算子；在java中，map算子接收的参数是Function对象，在Function中，需要设置第二个泛型类型为返回的新元素的类型；同时，call()方法的返回类型也需要与第二个泛型的返回类型一致。在call()方法中，对原始RDD中的每一个元素进行各种处理和计算，并返回一个新的元素，所有新的元素组成一个新的RDD。

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

举例：

package map.xls;

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.Function2;
import org.apache.spark.api.java.function.VoidFunction;

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

public class TransFormation_Map {

    public static void main(String[] args) {
        // 例1:map算子案例,将集合中每一个元素都乘以2
        map1();

        // 例2:map算子案例,将集合中每一个元素进行累加
        map2();
    }
    /*
    * 我们可以通过2种方式创建RDD，一种方式是直接读取外部数据(比较常用),另一种是在驱动程序中分发驱动器中的对象集合(list或set)，一般在调试中会使用
    * */


    public static void map1(){

        //创建SparkConf
        SparkConf conf = new SparkConf().setAppName("map").setMaster("local");

        //创建javaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);

        //构建集合
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        //并行化集合,parallelize对集合进行并行化处理(如果是在集群中，则会将list分配到集群的各个节点上),创建初始RDD
        JavaRDD<Integer> numberRDD = sc.parallelize(numbers);

        //使用map算子,将集合中每个元素都乘以2

        //map算子,是对于任何类型的RDD,都可以调用的
        //在java中,map算子接收的参数是Function对象
        //创建的function对象,一定会让你设置第二个泛型,这个泛型类型,并返回一个新的元素
        //所有新的元素就会组成一个新的RDD

        JavaRDD<Integer> rdd = numberRDD.map(new Function<Integer, Integer>() {
            public Integer call(Integer v1) throws Exception {
                return v1 * 2;
            }
        });

        rdd.foreach(new VoidFunction<Integer>() {

            public void call(Integer t) throws Exception {
                System.out.println(t);
            }
        });

        //关闭资源
        sc.close();


    }
    public static void map2(){
        // 创建sparkConf
        SparkConf conf = new SparkConf().setAppName("map2").setMaster("local");

        // 创建JavaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 要通过并行化集合的方式创建RDD，就要调用sparkContext及其子类的parallelize()方法
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        JavaRDD<Integer> numberRDD = sc.parallelize(numbers);

        // 执行reduce算子
        // 相等于先进行1+2=3，然后再进行3+3=6...
        int sum = numberRDD.reduce(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer num1, Integer num2) throws Exception {
                return num1 + num2;
            }
        });

        // 输出累加和
        System.out.println("1到10的累加和为：" + sum);
    }

}

2、flatMap算子

1、Similar to map, but each input item can be mapped to 0 or more output items (so func should return a Seq rather than a single item).

flatMap类似于map，但是每一个输出元素可以被映射成0或多个输出元素(所以func应该返回一个序列，而不是单一元素)

2、map是对RDD中元素逐一进行函数操作映射为另外一个RDD，而flatMap操作是将函数应用于RDD之中的每一个元素，将返回的迭代器的所有内容构成新的RDD。
flatMap与map区别在于map为“映射”，而flatMap“先映射，后扁平化”，map对每一次（func）都产生一个元素，返回一个对象，而flatMap多一步就是将所有对象合并为一个对象。

举例：

public static void main(String agrs[]){

    SparkConf conf = new SparkConf().setAppName("map").setMaster("local");

    JavaSparkContext sc = new JavaSparkContext(conf);

    int[] array=new int[]{1,2,3,4,5,6,7,8,9};

    List<Integer> list=new ArrayList<Integer>();

    for (Integer i : array) {
        list.add(i);
    }

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

    //flatMap和map一样是一个一个的传，但是他可以在每一个传入的值新增多个参数
    //list add方法：在指定位置插入元素，后面的元素都往后移一个元素。
    JavaRDD<Integer> result=rdd.flatMap(new FlatMapFunction<Integer, Integer>() {
        public java.util.Iterator<Integer> call(Integer t) throws Exception {

            List<Integer> list = new ArrayList<Integer>();
            for(int i = 0; i < t; i++){
                list.add(t + i);
            }
            return list.iterator();     //返回的这个list就是传入的元素及新增的内容
        }
    });
    System.out.println(result.collect());

}

输出结果：

[1, 2, 3, 3, 4, 5, 4, 5, 6, 7, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10, 11, 7, 8, 9, 10, 11, 12, 13, 8, 9, 10, 11, 12, 13, 14, 15, 9, 10, 11, 12, 13, 14, 15, 16, 17]

3、mapParitions算子

（1）mapPartitions类似于map，但是独立的在RDD的每一个分片上运行，假设有N个元素，有M个分区，那么使用map将被调用N次，而mapPartitions被调用M次，即一次处理一个分区。

（2）

举例：

4、filter算子

（1）Return a new RDD containing only the elements that satisfy a predicate.返回一个新的过滤后的RDD，过滤规则：只返回条件为true的数据。
（2）函数原型：public JavaPairRDD<K,V> filter(Function<scala.Tuple2<K,V>,Boolean> f)

private static void filter01() {
    // 创建SparkConf
    SparkConf conf = new SparkConf().setAppName("filter").setMaster("local");

    // 创建JavaSparkContext
    JavaSparkContext sc = new JavaSparkContext(conf);

    // 模拟集合
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

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

    // 对初始RDD执行filter算子，过滤出其中的偶数
    JavaRDD<Integer> evenNumberRDD = numberRDD.filter(new Function<Integer, Boolean>() {
                private static final long serialVersionUID = 1L;

                //偶数会保留下来，放在新的RDD中
                public Boolean call(Integer v1) throws Exception {
                    return v1 % 2 == 0;
                }

            });

    // 打印新的RDD
    evenNumberRDD.foreach(new VoidFunction<Integer>() {
        private static final long serialVersionUID = 1L;

        public void call(Integer t) throws Exception {
            System.out.println(t);
        }

    });

    // 关闭JavaSparkContext
    sc.close();
}

5、

6、

7、sample算子

1、JavaPairRDD<K,V> sample(boolean withReplacement,double fraction)
    JavaPairRDD<K,V> sample(boolean withReplacement,double fraction,long seed)
2、sample算子可以对RDD进行抽样，其中参数withReplacement为true时表示抽样之后还放回，可以被多次抽样，false表示不放回；
     fraction表示抽样比例；seed为随机数种子，比如当前时间戳。
3、sample应用的场景：在数据倾斜的时候，我们那么多数据如果想知道那个key倾斜了，就需要我们采样获取这些key，如果这些key数据不是很重要的话，可以过滤掉，这样就解决了数据倾斜。

例子：

package mapPartitions.xls;

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

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

public class TransFormation07_sample {
    public static void main(String args[]) {
        sample01();
    }

    public static void sample01(){

        SparkConf conf = new SparkConf().setAppName("TransFormation04_flatMap").setMaster("local");

        JavaSparkContext sc = new JavaSparkContext(conf);

        List<Integer> list=new ArrayList<Integer>();

        for(int i = 1;i <= 100;i++){
            list.add(i);
        }
        JavaRDD<Integer> any = sc.parallelize(list);

        //sample用来从RDD中抽取样本。他有三个参数
        //withReplacement：表示样本是否放回 true放回
        //fraction：抽取样本的比例
        //seed:随机数生成种子
        //由于样本的抽取其实是以一个固定的算法实现的，所以要达到随机抽样需用随机数生成seed

        JavaRDD<Integer> sample = any.sample(true, 0.1, 0);
        System.out.println("seed=0:" + sample.collect());
        sample = any.sample(true, 0.1, 0);
        System.out.println("seed=0:"+ sample.collect());             //由于seed相同，所以抽出样本是相同的

        //这里使用系统时间作为seed，发现抽出的样本是随机的
        JavaRDD<Integer> sample1 = any.sample(true, 0.1, System.currentTimeMillis());
        System.out.println("seed随机生成1" + sample1.collect());
        sample1=any.sample(true, 0.1, System.currentTimeMillis());
        System.out.println("seed随机生成2" + sample1.collect());
    }
}

输出结果：

seed=0:[10, 23, 25, 35, 50, 68, 69, 79, 79, 85, 91, 91]

seed=0:[10, 23, 25, 35, 50, 68, 69, 79, 79, 85, 91, 91]

seed随机生成1[13, 28, 45, 46, 57, 63, 68, 92]

seed随机生成2[3, 9, 48, 57, 64, 65, 71, 86, 88, 92]

8、distinct算子

1、Return a new RDD containing the distinct elements in this RDD. 返回去重的一个新的RDD

2、public JavaPairRDD<K,V> distinct();      public JavaPairRDD<K,V> distinct(int numPartitions)

3、Distinct的操作其实是把原RDD进行MAP操作,根据原来的KEY-VALUE生成为KEY,value使用null来替换,并对新生成的RDD执行reduceByKey的操作,这个reduceByKey的操作中,传入的x,y都是null,这个地方执行reduceByKey的函数执行完成reducebykey的操作后,这个时候新的RDD就只相同的key就只包含一个结果值(其实就是一个null),最后执行下map操作,这个操作返回的是RDD的第一个值,第一个值就是原始rdd的key-value.执行reduceByKey操作的默认的分区算子是Hash.这个功能在执行时也需要做shuffle的操作.也就是说,Distinct的操作是根据key与value一起计算不重复的结果.只有两个记录中key与value都不重复才算是不重复的数据。

4、distinct不改变分区数，但是分区的数据会去重后改变，不是单独去重。而且参数numPartitions指定多少分区，就会生成多少分区。有可能会返回空数据的分区。

例子：

public static void distinct02(){

        SparkConf sparkConf = new SparkConf().setMaster("local").setAppName("TransFormation08_distinct");

        JavaSparkContext sc = new JavaSparkContext(sparkConf);

        JavaPairRDD<String, String> javaPairRDD1 = sc.parallelizePairs(Lists.newArrayList(
                new Tuple2<String, String>("cat", "11"),
                new Tuple2<String, String>("dog", "22"),
                new Tuple2<String, String>("cat", "11"),
                new Tuple2<String, String>("pig", "44"),
                new Tuple2<String, String>("duck", "55"),
                new Tuple2<String, String>("cat", "11"),
                new Tuple2<String, String>("cat", "12"),
                new Tuple2<String, String>("dog", "23"),
                new Tuple2<String, String>("cat", "11"),
                new Tuple2<String, String>("pig", "22"),
                new Tuple2<String, String>("duck", "55"),
                new Tuple2<String, String>("cat", "15")), 2);
        // 先输出一次创建的Tuple2
        javaPairRDD1.foreach(new VoidFunction<Tuple2<String, String>>() {
            public void call(Tuple2<String, String> stringStringTuple2) throws Exception {
                System.out.println(stringStringTuple2);
            }
        });

        // 去重操作
        JavaPairRDD<String,String> javaPairRDD = javaPairRDD1.distinct();

        // 输出去重后的结果
        javaPairRDD.foreach(new VoidFunction<Tuple2<String, String>>() {
            public void call(Tuple2<String, String> stringStringTuple2) throws Exception {
                System.out.println(stringStringTuple2);
            }
        });

        // 输出分区数---验证去重是否影响分区
        System.out.println("分区的个数："+javaPairRDD.partitions().size());

        // 验证带有numPartitions参数的distinct
        JavaPairRDD<String,String> javaPairRDD2 = javaPairRDD1.distinct(3);

        javaPairRDD2.foreach(new VoidFunction<Tuple2<String, String>>() {
            public void call(Tuple2<String, String> stringStringTuple2) throws Exception {
                System.out.println("-->"+stringStringTuple2);
            }
        });
        // 输出分区数
        System.out.println("分区的个数："+javaPairRDD2.partitions().size());
    }

输出结果：

(cat,11)

(dog,22)

(cat,11)

(pig,44)

(duck,55)

(cat,11)

(cat,12)

(dog,23)

(cat,11)

(pig,22)

(duck,55)

(cat,15)

 

 

(cat,15)

(cat,12)

(cat,11)

(pig,22)

(pig,44)

(dog,23)

(dog,22)

(duck,55)

 

分区的个数：2

 

-->(cat,15)

-->(dog,22)

-->(duck,55)

-->(pig,22)

-->(pig,44)

-->(dog,23)

-->(cat,12)

-->(cat,11)

 

分区的个数：3

9、groupByKey

package mapPartitions.xls;

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

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

public class TransFormation22_groupByKey {
    public static void main(String args[]) {
        groupByKey01();
    }

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

        // 模拟集合
        List<Tuple2<String, Integer>> scoreList = Arrays.asList(
                new Tuple2<String, Integer>("class1", 80),
                new Tuple2<String, Integer>("class2", 75),
                new Tuple2<String, Integer>("class1", 90),
                new Tuple2<String, Integer>("class2", 65),
                new Tuple2<String, Integer>("class3", 55),
                new Tuple2<String, Integer>("class3", 65),
                new Tuple2<String, Integer>("class4", 75),
                new Tuple2<String, Integer>("class5", 95));

        // 并行化集合，创建JavaPairRDD
        JavaPairRDD<String, Integer> scores = sc.parallelizePairs(scoreList);

        // 针对scores RDD，执行groupByKey算子，对每个班级的成绩进行分组
        JavaPairRDD<String, Iterable<Integer>> groupedScores = scores.groupByKey();

        // 打印groupedScores RDD
        groupedScores.foreach(new VoidFunction<Tuple2<String,Iterable<Integer>>>() {

            private static final long serialVersionUID = 1L;

            public void call(Tuple2<String, Iterable<Integer>> t) throws Exception {

                System.out.println("class: " + t._1);
                Iterator<Integer> ite = t._2.iterator();
                while(ite.hasNext()) {
                    System.out.println(ite.next());
                }
                System.out.println("==============================");
            }
        });

        // 关闭JavaSparkContext
        sc.close();
    }
}

输出结果：

class: class5
95
==============================
class: class3
55
65
==============================
class: class1
80
90
==============================
class: class4
75
==============================
class: class2
75
65
==============================

10、groupByKey算子

         /**
     * reduceByKey案例：统计每个班级的总分
     */
    private static void reduceByKey() {
        // 创建SparkConf
        SparkConf conf = new SparkConf()
                .setAppName("reduceByKey")  
                .setMaster("local");
        // 创建JavaSparkContext
        JavaSparkContext sc = new JavaSparkContext(conf);
        
        // 模拟集合
        List<Tuple2<String, Integer>> scoreList = Arrays.asList(
                new Tuple2<String, Integer>("class1", 80),
                new Tuple2<String, Integer>("class2", 75),
                new Tuple2<String, Integer>("class1", 90),
                new Tuple2<String, Integer>("class2", 65));
        
        // 并行化集合，创建JavaPairRDD
        JavaPairRDD<String, Integer> scores = sc.parallelizePairs(scoreList);
        
        // 针对scores RDD，执行reduceByKey算子
        JavaPairRDD<String, Integer> totalScores = scores.reduceByKey(
                
                new Function2<Integer, Integer, Integer>() {
                    
                    private static final long serialVersionUID = 1L;
                    
                    public Integer call(Integer v1, Integer v2) throws Exception {
                        return v1 + v2;
                    }
                    
                });
        
        // 打印totalScores RDD
        totalScores.foreach(new VoidFunction<Tuple2<String,Integer>>() {

            private static final long serialVersionUID = 1L;

            public void call(Tuple2<String, Integer> t) throws Exception {
                System.out.println(t._1 + ": " + t._2);   
            }
            
        });
        
        // 关闭JavaSparkContext
        sc.close();
    }

总结groupByKey和reduceByKey的区别：

当采用reduceByKeyt时，Spark可以在每个分区移动数据之前将待输出数据与一个共用的key结合。借助下图可以理解在reduceByKey里究竟发生了什么。 注意在数据对被搬移前同一机器上同样的key是怎样被组合的(reduceByKey中的lamdba函数)。然后lamdba函数在每个区上被再次调用来将所有值reduce成一个最终结果。整个过程如下：

 （2）当采用groupByKey时，由于它不接收函数，spark只能先将所有的键值对(key-value pair)都移动，这样的后果是集群节点之间的开销很大，导致传输延时。整个过程如下：

因此，在对大数据进行复杂计算时，reduceByKey优于groupByKey。

另外，如果仅仅是group处理，那么以下函数应该优先于 groupByKey ：
　　（1）combineByKey 组合数据，但是组合之后的数据类型与输入时值的类型不一样。
　　（2）foldByKey合并每一个 key 的所有值，在级联函数和“零值”中使用。