- 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。
举例：
1 package map.xls; 2 3 import org.apache.spark.SparkConf; 4 import org.apache.spark.api.java.JavaRDD; 5 import org.apache.spark.api.java.JavaSparkContext; 6 import org.apache.spark.api.java.function.Function; 7 import org.apache.spark.api.java.function.Function2; 8 import org.apache.spark.api.java.function.VoidFunction; 9 10 import java.util.Arrays; 11 import java.util.List; 12 13 public class TransFormation_Map { 14 15 public static void main(String[] args) { 16 // 例1:map算子案例,将集合中每一个元素都乘以2 17 map1(); 18 19 // 例2:map算子案例,将集合中每一个元素进行累加 20 map2(); 21 } 22 /* 23 * 我们可以通过2种方式创建RDD，一种方式是直接读取外部数据(比较常用),另一种是在驱动程序中分发驱动器中的对象集合(list或set)，一般在调试中会使用 24 * */ 25 26 27 public static void map1(){ 28 29 //创建SparkConf 30 SparkConf conf = new SparkConf().setAppName("map").setMaster("local"); 31 32 //创建javaSparkContext 33 JavaSparkContext sc = new JavaSparkContext(conf); 34 35 //构建集合 36 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); 37 38 //并行化集合,parallelize对集合进行并行化处理(如果是在集群中，则会将list分配到集群的各个节点上),创建初始RDD 39 JavaRDD<Integer> numberRDD = sc.parallelize(numbers); 40 41 //使用map算子,将集合中每个元素都乘以2 42 43 //map算子,是对于任何类型的RDD,都可以调用的 44 //在java中,map算子接收的参数是Function对象 45 //创建的function对象,一定会让你设置第二个泛型,这个泛型类型,并返回一个新的元素 46 //所有新的元素就会组成一个新的RDD 47 48 JavaRDD<Integer> rdd = numberRDD.map(new Function<Integer, Integer>() { 49 public Integer call(Integer v1) throws Exception { 50 return v1 * 2; 51 } 52 }); 53 54 rdd.foreach(new VoidFunction<Integer>() { 55 56 public void call(Integer t) throws Exception { 57 System.out.println(t); 58 } 59 }); 60 61 //关闭资源 62 sc.close(); 63 64 65 } 66 public static void map2(){ 67 // 创建sparkConf 68 SparkConf conf = new SparkConf().setAppName("map2").setMaster("local"); 69 70 // 创建JavaSparkContext 71 JavaSparkContext sc = new JavaSparkContext(conf); 72 73 // 要通过并行化集合的方式创建RDD，就要调用sparkContext及其子类的parallelize()方法 74 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 75 JavaRDD<Integer> numberRDD = sc.parallelize(numbers); 76 77 // 执行reduce算子 78 // 相等于先进行1+2=3，然后再进行3+3=6... 79 int sum = numberRDD.reduce(new Function2<Integer, Integer, Integer>() { 80 public Integer call(Integer num1, Integer num2) throws Exception { 81 return num1 + num2; 82 } 83 }); 84 85 // 输出累加和 86 System.out.println("1到10的累加和为：" + sum); 87 } 88 89 }
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多一步就是将所有对象合并为一个对象。
举例：
1 public static void main(String agrs[]){ 2 3 SparkConf conf = new SparkConf().setAppName("map").setMaster("local"); 4 5 JavaSparkContext sc = new JavaSparkContext(conf); 6 7 int[] array=new int[]{1,2,3,4,5,6,7,8,9}; 8 9 List<Integer> list=new ArrayList<Integer>(); 10 11 for (Integer i : array) { 12 list.add(i); 13 } 14 15 JavaRDD<Integer> rdd=sc.parallelize(list,2); 16 17 //flatMap和map一样是一个一个的传，但是他可以在每一个传入的值新增多个参数 18 //list add方法：在指定位置插入元素，后面的元素都往后移一个元素。 19 JavaRDD<Integer> result=rdd.flatMap(new FlatMapFunction<Integer, Integer>() { 20 public java.util.Iterator<Integer> call(Integer t) throws Exception { 21 22 List<Integer> list = new ArrayList<Integer>(); 23 for(int i = 0; i < t; i++){ 24 list.add(t + i); 25 } 26 return list.iterator(); //返回的这个list就是传入的元素及新增的内容 27 } 28 }); 29 System.out.println(result.collect()); 30 31 }
输出结果：
[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)
1 private static void filter01() { 2 // 创建SparkConf 3 SparkConf conf = new SparkConf().setAppName("filter").setMaster("local"); 4 5 // 创建JavaSparkContext 6 JavaSparkContext sc = new JavaSparkContext(conf); 7 8 // 模拟集合 9 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 10 11 // 并行化集合，创建初始RDD 12 JavaRDD<Integer> numberRDD = sc.parallelize(numbers); 13 14 // 对初始RDD执行filter算子，过滤出其中的偶数 15 JavaRDD<Integer> evenNumberRDD = numberRDD.filter(new Function<Integer, Boolean>() { 16 private static final long serialVersionUID = 1L; 17 18 //偶数会保留下来，放在新的RDD中 19 public Boolean call(Integer v1) throws Exception { 20 return v1 % 2 == 0; 21 } 22 23 }); 24 25 // 打印新的RDD 26 evenNumberRDD.foreach(new VoidFunction<Integer>() { 27 private static final long serialVersionUID = 1L; 28 29 public void call(Integer t) throws Exception { 30 System.out.println(t); 31 } 32 33 }); 34 35 // 关闭JavaSparkContext 36 sc.close(); 37 }
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数据不是很重要的话，可以过滤掉，这样就解决了数据倾斜。
例子：
1 package mapPartitions.xls; 2 3 import org.apache.spark.SparkConf; 4 import org.apache.spark.api.java.JavaRDD; 5 import org.apache.spark.api.java.JavaSparkContext; 6 7 import java.util.ArrayList; 8 import java.util.List; 9 10 public class TransFormation07_sample { 11 public static void main(String args[]) { 12 sample01(); 13 } 14 15 public static void sample01(){ 16 17 SparkConf conf = new SparkConf().setAppName("TransFormation04_flatMap").setMaster("local"); 18 19 JavaSparkContext sc = new JavaSparkContext(conf); 20 21 List<Integer> list=new ArrayList<Integer>(); 22 23 for(int i = 1;i <= 100;i++){ 24 list.add(i); 25 } 26 JavaRDD<Integer> any = sc.parallelize(list); 27 28 //sample用来从RDD中抽取样本。他有三个参数 29 //withReplacement：表示样本是否放回 true放回 30 //fraction：抽取样本的比例 31 //seed:随机数生成种子 32 //由于样本的抽取其实是以一个固定的算法实现的，所以要达到随机抽样需用随机数生成seed 33 34 JavaRDD<Integer> sample = any.sample(true, 0.1, 0); 35 System.out.println("seed=0:" + sample.collect()); 36 sample = any.sample(true, 0.1, 0); 37 System.out.println("seed=0:"+ sample.collect()); //由于seed相同，所以抽出样本是相同的 38 39 //这里使用系统时间作为seed，发现抽出的样本是随机的 40 JavaRDD<Integer> sample1 = any.sample(true, 0.1, System.currentTimeMillis()); 41 System.out.println("seed随机生成1" + sample1.collect()); 42 sample1=any.sample(true, 0.1, System.currentTimeMillis()); 43 System.out.println("seed随机生成2" + sample1.collect()); 44 } 45 }
输出结果：
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指定多少分区，就会生成多少分区。有可能会返回空数据的分区。
例子：
1 public static void distinct02(){ 2 3 SparkConf sparkConf = new SparkConf().setMaster("local").setAppName("TransFormation08_distinct"); 4 5 JavaSparkContext sc = new JavaSparkContext(sparkConf); 6 7 JavaPairRDD<String, String> javaPairRDD1 = sc.parallelizePairs(Lists.newArrayList( 8 new Tuple2<String, String>("cat", "11"), 9 new Tuple2<String, String>("dog", "22"), 10 new Tuple2<String, String>("cat", "11"), 11 new Tuple2<String, String>("pig", "44"), 12 new Tuple2<String, String>("duck", "55"), 13 new Tuple2<String, String>("cat", "11"), 14 new Tuple2<String, String>("cat", "12"), 15 new Tuple2<String, String>("dog", "23"), 16 new Tuple2<String, String>("cat", "11"), 17 new Tuple2<String, String>("pig", "22"), 18 new Tuple2<String, String>("duck", "55"), 19 new Tuple2<String, String>("cat", "15")), 2); 20 // 先输出一次创建的Tuple2 21 javaPairRDD1.foreach(new VoidFunction<Tuple2<String, String>>() { 22 public void call(Tuple2<String, String> stringStringTuple2) throws Exception { 23 System.out.println(stringStringTuple2); 24 } 25 }); 26 27 // 去重操作 28 JavaPairRDD<String,String> javaPairRDD = javaPairRDD1.distinct(); 29 30 // 输出去重后的结果 31 javaPairRDD.foreach(new VoidFunction<Tuple2<String, String>>() { 32 public void call(Tuple2<String, String> stringStringTuple2) throws Exception { 33 System.out.println(stringStringTuple2); 34 } 35 }); 36 37 // 输出分区数---验证去重是否影响分区 38 System.out.println("分区的个数："+javaPairRDD.partitions().size()); 39 40 // 验证带有numPartitions参数的distinct 41 JavaPairRDD<String,String> javaPairRDD2 = javaPairRDD1.distinct(3); 42 43 javaPairRDD2.foreach(new VoidFunction<Tuple2<String, String>>() { 44 public void call(Tuple2<String, String> stringStringTuple2) throws Exception { 45 System.out.println("-->"+stringStringTuple2); 46 } 47 }); 48 // 输出分区数 49 System.out.println("分区的个数："+javaPairRDD2.partitions().size()); 50 }
输出结果：
(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
1 package mapPartitions.xls; 2 3 import org.apache.spark.SparkConf; 4 import org.apache.spark.api.java.JavaPairRDD; 5 import org.apache.spark.api.java.JavaSparkContext; 6 import org.apache.spark.api.java.function.VoidFunction; 7 import scala.Tuple2; 8 9 import java.util.Arrays; 10 import java.util.Iterator; 11 import java.util.List; 12 13 public class TransFormation22_groupByKey { 14 public static void main(String args[]) { 15 groupByKey01(); 16 } 17 18 public static void groupByKey01(){ 19 // 创建SparkConf 20 SparkConf conf = new SparkConf().setAppName("groupByKey").setMaster("local"); 21 // 创建JavaSparkContext 22 JavaSparkContext sc = new JavaSparkContext(conf); 23 24 // 模拟集合 25 List<Tuple2<String, Integer>> scoreList = Arrays.asList( 26 new Tuple2<String, Integer>("class1", 80), 27 new Tuple2<String, Integer>("class2", 75), 28 new Tuple2<String, Integer>("class1", 90), 29 new Tuple2<String, Integer>("class2", 65), 30 new Tuple2<String, Integer>("class3", 55), 31 new Tuple2<String, Integer>("class3", 65), 32 new Tuple2<String, Integer>("class4", 75), 33 new Tuple2<String, Integer>("class5", 95)); 34 35 // 并行化集合，创建JavaPairRDD 36 JavaPairRDD<String, Integer> scores = sc.parallelizePairs(scoreList); 37 38 // 针对scores RDD，执行groupByKey算子，对每个班级的成绩进行分组 39 JavaPairRDD<String, Iterable<Integer>> groupedScores = scores.groupByKey(); 40 41 // 打印groupedScores RDD 42 groupedScores.foreach(new VoidFunction<Tuple2<String,Iterable<Integer>>>() { 43 44 private static final long serialVersionUID = 1L; 45 46 public void call(Tuple2<String, Iterable<Integer>> t) throws Exception { 47 48 System.out.println("class: " + t._1); 49 Iterator<Integer> ite = t._2.iterator(); 50 while(ite.hasNext()) { 51 System.out.println(ite.next()); 52 } 53 System.out.println("=============================="); 54 } 55 }); 56 57 // 关闭JavaSparkContext 58 sc.close(); 59 } 60 }
输出结果：
class: class5
95
==============================
class: class3
55
65
==============================
class: class1
80
90
==============================
class: class4
75
==============================
class: class2
75
65
==============================
10、groupByKey算子
1 /** 2 * reduceByKey案例：统计每个班级的总分 3 */ 4 private static void reduceByKey() { 5 // 创建SparkConf 6 SparkConf conf = new SparkConf() 7 .setAppName("reduceByKey") 8 .setMaster("local"); 9 // 创建JavaSparkContext 10 JavaSparkContext sc = new JavaSparkContext(conf); 11 12 // 模拟集合 13 List<Tuple2<String, Integer>> scoreList = Arrays.asList( 14 new Tuple2<String, Integer>("class1", 80), 15 new Tuple2<String, Integer>("class2", 75), 16 new Tuple2<String, Integer>("class1", 90), 17 new Tuple2<String, Integer>("class2", 65)); 18 19 // 并行化集合，创建JavaPairRDD 20 JavaPairRDD<String, Integer> scores = sc.parallelizePairs(scoreList); 21 22 // 针对scores RDD，执行reduceByKey算子 23 JavaPairRDD<String, Integer> totalScores = scores.reduceByKey( 24 25 new Function2<Integer, Integer, Integer>() { 26 27 private static final long serialVersionUID = 1L; 28 29 public Integer call(Integer v1, Integer v2) throws Exception { 30 return v1 + v2; 31 } 32 33 }); 34 35 // 打印totalScores RDD 36 totalScores.foreach(new VoidFunction<Tuple2<String,Integer>>() { 37 38 private static final long serialVersionUID = 1L; 39 40 public void call(Tuple2<String, Integer> t) throws Exception { 41 System.out.println(t._1 + ": " + t._2); 42 } 43 44 }); 45 46 // 关闭JavaSparkContext 47 sc.close(); 48 }
总结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 的所有值，在级联函数和“零值”中使用。