sparkJavaApi逐个详解

说明：掌握spark的一个关键，就是要深刻理解掌握RDD各个函数的使用场景，这样我们在写业务逻辑的时候就知道在什么时候用什么样的函数去实现，得心应手，本文将逐步收集整理各种函数原理及示例代码，持续更新，方便大家学习掌握。

函数列表：

1、join的使用
2、cogroup的使用
3、GroupByKey的使用
4、map的使用
5、flatmap的使用
6、mapPartitions的使用
7、mapPartitionsWithIndex的使用
8、sortBy的使用
9、takeOrdered的使用
10、takeSample的使用
11、distinct的使用
12、cartesian的使用
13、fold的使用
14、countByKey的使用
15、reduce的使用
16、aggregate的使用
17、aggregateByKey的使用
18、foreach的使用
19、foreachPartition的使用
20、lookup的使用
21、saveAsTextFile的使用
22、saveAsObjectFile的使用
23、treeAggregate的使用
24、treeReduce的使用

1、join的使用

官方文档描述：

Return an RDD containing all pairs of elements with matching keys in `this` and `other`. 
Each* pair of elements will be returned as a (k, (v1, v2)) tuple, 
where (k, v1) is in `this` and* (k, v2) is in `other`. 
Performs a hash join across the cluster.

函数原型：

def join[W](other: JavaPairRDD[K, W]): JavaPairRDD[K, (V, W)]
def join[W](other: JavaPairRDD[K, W], numPartitions: Int): JavaPairRDD[K, (V, W)]
def join[W](other: JavaPairRDD[K, W], partitioner: Partitioner): JavaPairRDD[K, (V, W)]

将一组数据转化为RDD后，分别创造出两个PairRDD，然后再对两个PairRDD进行归约（即合并相同Key对应的Value），过程如下图所示：

代码实现如下：

public class SparkRDDDemo {  
    public static void main(String[] args){  
        SparkConf conf = new SparkConf().setAppName("SparkRDD").setMaster("local");  
        JavaSparkContext sc = new JavaSparkContext(conf);  
  
        List<Integer> data = Arrays.asList(1,2,3,4,5);  
        JavaRDD<Integer> rdd = sc.parallelize(data);  
  
        //FirstRDD  
        JavaPairRDD<Integer, Integer> firstRDD = rdd.mapToPair(new PairFunction<Integer, Integer, Integer>() {  
            @Override  
            public Tuple2<Integer, Integer> call(Integer num) throws Exception {  
                return new Tuple2<>(num, num * num);  
            }  
        });  
  
        //SecondRDD  
        JavaPairRDD<Integer, String> secondRDD = rdd.mapToPair(new PairFunction<Integer, Integer, String>() {  
            @Override  
            public Tuple2<Integer, String> call(Integer num) throws Exception {  
                return new Tuple2<>(num, String.valueOf((char)(64 + num * num)));  
            }  
        });  
  
        JavaPairRDD<Integer, Tuple2<Integer, String>> joinRDD = firstRDD.join(secondRDD);  
  
        JavaRDD<String> res = joinRDD.map(new Function<Tuple2<Integer, Tuple2<Integer, String>>, String>() {  
            @Override  
            public String call(Tuple2<Integer, Tuple2<Integer, String>> integerTuple2Tuple2) throws Exception {  
                int key = integerTuple2Tuple2._1();  
                int value1 = integerTuple2Tuple2._2()._1();  
                String value2 = integerTuple2Tuple2._2()._2();  
                return "<" + key + ",<" + value1 + "," + value2 + ">>";  
            }  
        });  
  
        List<String> resList = res.collect();  
        for(String str : resList)  
            System.out.println(str);  
  
        sc.stop();  
    }  
}  

　　补充1

 join就是把两个集合根据key,进行内容聚合; 

 元组集合A:(1,"Spark"),(2,"Tachyon"),(3,"Hadoop")

 元组集合B:(1,100),(2,95),(3,65)                                

 A join B的结果:(1,("Spark",100)),(3,("hadoop",65)),(2,("Tachyon",95))

源码分析：

def join[W](other: RDD[(K, W)], partitioner: Partitioner): RDD[(K, (V, W))] = self.withScope {  
  this.cogroup(other, partitioner).flatMapValues( pair =>    
    for (v <- pair._1.iterator; w <- pair._2.iterator) yield (v, w)  
  )
}

**
从源码中可以看出，join() 将两个 RDD[(K, V)] 按照 SQL 中的 join 方式聚合在一起。与 intersection() 类似，首先进行 cogroup()， 得到 <K, (Iterable[V1], Iterable[V2])> 类型的 MappedValuesRDD，然后对 Iterable[V1] 和 Iterable[V2] 做笛卡尔集，并将集合 flat() 化。
**

实例：

List<Integer> data = Arrays.asList(1, 2, 4, 3, 5, 6, 7);
final Random random = new Random();
JavaRDD<Integer> javaRDD = javaSparkContext.parallelize(data);
JavaPairRDD<Integer,Integer> javaPairRDD = javaRDD.mapToPair(new PairFunction<Integer, Integer, Integer>() {    
  @Override    
  public Tuple2<Integer, Integer> call(Integer integer) throws Exception {        
    return new Tuple2<Integer, Integer>(integer,random.nextInt(10));    
  }
});

JavaPairRDD<Integer,Tuple2<Integer,Integer>> joinRDD = javaPairRDD.join(javaPairRDD);
System.out.println(joinRDD.collect());

JavaPairRDD<Integer,Tuple2<Integer,Integer>> joinRDD2 = javaPairRDD.join(javaPairRDD,2);
System.out.println(joinRDD2.collect());

JavaPairRDD<Integer,Tuple2<Integer,Integer>> joinRDD3 = javaPairRDD.join(javaPairRDD, new Partitioner() {    
  @Override    
  public int numPartitions() {        
    return 2;    
  }    
  @Override    
  public int getPartition(Object key) {        
    return (key.toString()).hashCode()%numPartitions();
    }
});
System.out.println(joinRDD3.collect());

2.cogroup的使用

cogroup就是:

有两个元组Tuple的集合A与B,先对A组集合中key相同的value进行聚合,

                        然后对B组集合中key相同的value进行聚合,之后对A组与B组进行"join"操作;  

示例代码：

public class CoGroup {  
      
    public static void main(String[] args) {  
            SparkConf conf=new SparkConf().setAppName("spark WordCount!").setMaster("local");  
            JavaSparkContext sContext=new JavaSparkContext(conf);  
            List<Tuple2<Integer,String>> namesList=Arrays.asList(  
                    new Tuple2<Integer, String>(1,"Spark"),  
                    new Tuple2<Integer, String>(3,"Tachyon"),  
                    new Tuple2<Integer, String>(4,"Sqoop"),  
                    new Tuple2<Integer, String>(2,"Hadoop"),  
                    new Tuple2<Integer, String>(2,"Hadoop2")  
                    );  
              
            List<Tuple2<Integer,Integer>> scoresList=Arrays.asList(  
                    new Tuple2<Integer, Integer>(1,100),  
                    new Tuple2<Integer, Integer>(3,70),  
                    new Tuple2<Integer, Integer>(3,77),  
                    new Tuple2<Integer, Integer>(2,90),  
                    new Tuple2<Integer, Integer>(2,80)  
                    );            
            JavaPairRDD<Integer, String> names=sContext.parallelizePairs(namesList);  
            JavaPairRDD<Integer, Integer> scores=sContext.parallelizePairs(scoresList);  
            /** 
             * <Integer> JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> 
             * org.apache.spark.api.java.JavaPairRDD.cogroup(JavaPairRDD<Integer, Integer> other) 
             */  
            JavaPairRDD<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> nameScores=names.cogroup(scores);           
              
            nameScores.foreach(new VoidFunction<Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>>>() {  
                private static final long serialVersionUID = 1L;  
                int i=1;  
                @Override  
                public void call(  
                        Tuple2<Integer, Tuple2<Iterable<String>, Iterable<Integer>>> t)  
                        throws Exception {  
                        String string="ID:"+t._1+" , "+"Name:"+t._2._1+" , "+"Score:"+t._2._2;  
                        string+="     count:"+i;  
                        System.out.println(string);  
                        i++;  
                }  
            });  
              
            sContext.close();  
    }  
}  

示例结果:

1. ID:4 , Name:[Sqoop] , Score:[]     count:1  
2. ID:1 , Name:[Spark] , Score:[100]     count:2  
3. ID:3 , Name:[Tachyon] , Score:[70, 77]     count:3  
4. ID:2 , Name:[Hadoop, Hadoop2] , Score:[90, 80]     count:4  

官方文档描述：

For each key k in `this` or `other`, return a resulting RDD that contains a tuple 
with the list of values for that key in `this` as well as `other`.

List<Integer> data = Arrays.asList(1, 2, 4, 3, 5, 6, 7, 1, 2);
JavaRDD<Integer> javaRDD = javaSparkContext.parallelize(data);

JavaPairRDD<Integer,Integer> javaPairRDD = javaRDD.mapToPair(new PairFunction<Integer, Integer, Integer>() {    
@Override    
  public Tuple2<Integer, Integer> call(Integer integer) throws Exception {        
    return new Tuple2<Integer, Integer>(integer,1);    
  }
});

//与 groupByKey() 不同，cogroup() 要 aggregate 两个或两个以上的 RDD。
JavaPairRDD<Integer,Tuple2<Iterable<Integer>,Iterable<Integer>>> cogroupRDD = javaPairRDD.cogroup(javaPairRDD);
System.out.println(cogroupRDD.collect());

JavaPairRDD<Integer,Tuple2<Iterable<Integer>,Iterable<Integer>>> cogroupRDD3 = javaPairRDD.cogroup(javaPairRDD, new Partitioner() {    
    @Override    
    public int numPartitions() {        
      return 2;    
    }    
    @Override    
    public int getPartition(Object key) {        
      return (key.toString()).hashCode()%numPartitions();
    }
});
System.out.println(cogroupRDD3);

3、GroupByKey的使用

感觉reduceByKey只能完成一些满足交换率，结合律的运算，如果想把某些数据聚合到一些做一些操作，得换groupbykey

比如下面：我想把相同key对应的value收集到一起，完成一些运算（例如拼接字符串，或者去重） 

public class SparkSample {  
    private static final Pattern SPACE = Pattern.compile(" ");  
  
    public static void main(String args[]) {  
        SparkConf sparkConf = new SparkConf();  
        sparkConf.setAppName("Spark_GroupByKey_Sample");  
        sparkConf.setMaster("local");  
  
        JavaSparkContext context = new JavaSparkContext(sparkConf);  
  
        List<Integer> data = Arrays.asList(1,1,2,2,1);  
        JavaRDD<Integer> distData= context.parallelize(data);  
  
        JavaPairRDD<Integer, Integer> firstRDD = distData.mapToPair(new PairFunction<Integer, Integer, Integer>() {  
            @Override  
            public Tuple2<Integer, Integer> call(Integer integer) throws Exception {  
                return new Tuple2(integer, integer*integer);  
            }  
        });  
  
        JavaPairRDD<Integer, Iterable<Integer>> secondRDD = firstRDD.groupByKey();  
  
        List<Tuple2<Integer, String>> reslist = secondRDD.map(new Function<Tuple2<Integer, Iterable<Integer>>, Tuple2<Integer, String>>() {  
            @Override  
            public Tuple2<Integer, String> call(Tuple2<Integer, Iterable<Integer>> integerIterableTuple2) throws Exception {  
                int key = integerIterableTuple2._1();  
                StringBuffer sb = new StringBuffer();  
                Iterable<Integer> iter = integerIterableTuple2._2();  
                for (Integer integer : iter) {  
                        sb.append(integer).append(" ");  
                }  
                return new Tuple2(key, sb.toString().trim());  
            }  
        }).collect();  
  
  
        for(Tuple2<Integer, String> str : reslist) {  
            System.out.println(str._1() + "	" + str._2() );  
        }  
        context.stop();  
    }  
}  

补充1  引自：http://blog.csdn.net/zongzhiyuan/article/details/49965021

在spark中，我们知道一切的操作都是基于RDD的。在使用中，RDD有一种非常特殊也是非常实用的format——pair RDD，即RDD的每一行是（key, value）的格式。这种格式很像Python的字典类型，便于针对key进行一些处理。

针对pair RDD这样的特殊形式，spark中定义了许多方便的操作，今天主要介绍一下reduceByKey和groupByKey，因为在接下来讲解《在spark中如何实现SQL中的group_concat功能？》时会用到这两个operations。

首先，看一看spark官网[1]是怎么解释的：

reduceByKey(func, numPartitions=None)

Merge the values for each key using an associative reduce function. This will also perform the merginglocally on each mapper before sending results to a reducer, similarly to a “combiner” in MapReduce. Output will be hash-partitioned with numPartitions partitions, or the default parallelism level if numPartitions is not specified.

也就是，reduceByKey用于对每个key对应的多个value进行merge操作，最重要的是它能够在本地先进行merge操作，并且merge操作可以通过函数自定义。

groupByKey(numPartitions=None)

Group the values for each key in the RDD into a single sequence. Hash-partitions the resulting RDD with numPartitions partitions. Note: If you are grouping in order to perform an aggregation (such as a sum or average) over each key, using reduceByKey or aggregateByKey will provide much better performance.

也就是，groupByKey也是对每个key进行操作，但只生成一个sequence。需要特别注意“Note”中的话，它告诉我们：如果需要对sequence进行aggregation操作（注意，groupByKey本身不能自定义操作函数），那么，选择reduceByKey/aggregateByKey更好。这是因为groupByKey不能自定义函数，我们需要先用groupByKey生成RDD，然后才能对此RDD通过map进行自定义函数操作。

为了更好的理解上面这段话，下面我们使用两种不同的方式去计算单词的个数[2]：

val words = Array("one", "two", "two", "three", "three", "three")

val wordPairsRDD = sc.parallelize(words).map(word => (word, 1))

val wordCountsWithReduce = wordPairsRDD.reduceByKey(_ + _)

val wordCountsWithGroup = wordPairsRDD.groupByKey().map(t => (t._1, t._2.sum))

上面得到的wordCountsWithReduce和wordCountsWithGroup是完全一样的，但是，它们的内部运算过程是不同的。

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

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

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

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

最后，对reduceByKey中的func做一些介绍：

如果是用Python写的spark，那么有一个库非常实用：operator[3]，其中可以用的函数包括：大小比较函数，逻辑操作函数，数学运算函数，序列操作函数等等。这些函数可以直接通过“from operator import *”进行调用，直接把函数名作为参数传递给reduceByKey即可。如下：

<span style="font-size:14px;">from operator import add
rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
sorted(rdd.reduceByKey(add).collect())

[('a', 2), ('b', 1)]</span>