Spark：Java实现Action操作

完整代码如下：

package cn.spark.study.core;

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

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
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 scala.Tuple2;

/**
 * action 操作实战
 * @author Administrator
 *
 */
@SuppressWarnings(value = {"unused","unchecked"})
public class ActionOperation_7 {

public static void main(String[] args) {
    reduce(); 
    collect();
    count();
    take();
    //saveAsTextFile();
    countByKey();
    //foreach()
}

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

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

    //有一个集合，里面有1到10 ，现在对1-10累加
    List<Integer> numberList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    //并行化一个集合
    JavaRDD <Integer> numbers = sc.parallelize(numberList);

    //使用reduce操作对集合中的数进行累加
    //reduce操作原理：
        //首先将第一个和第二个元素，传入call()方法，进行计算，会获取一个结果
        //接着将该结果与下一个元素传入call()方法，进行计算。依次类推
    //reduce操作的本质就是聚合，将多个元素聚合成一个元素
    int sum = numbers.reduce(new Function2<Integer, Integer, Integer>() {

        private static final long serialVersionUID = 1L;

        @Override
        public Integer call(Integer v1, Integer v2) throws Exception {
            return v1+v2;
        }
    });

    System.out.println(sum);

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

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

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

    //有一个集合，里面有1到10 ，现在对1-10累加
    List<Integer> numberList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    //并行化一个集合
    JavaRDD <Integer> numbers = sc.parallelize(numberList);

    //使用map操作将集合中的所有数字乘以2
    JavaRDD<Integer> doubleNumber = numbers.map(new Function<Integer, Integer>() {

        private static final long serialVersionUID = 1L;

        @Override
        public Integer call(Integer v) throws Exception {
            return v*2;
        }
    });

    //不用foreach action操作，在远程集群上遍历rdd中的元素
    //而使用collect操作，将分布在远程集群上的doubleNumber RDD的数据拉渠道本地
    //这种方式一般不建议使用，因为如果RDD中的数据量比较大的话，比如超过1w条
    //那么性能会比较差，因为从远程走大量的网络传输，将数据获取到本地
        //此外，除了性能差，还可能在RDD中数据量特别大的情况下，发生om异常，内存溢出
    //因此通过还是推荐使用foreach action操作，来对最终的rdd元素进行处理
    List<Integer> doubleNumberList = doubleNumber.collect();
    for(Integer num :doubleNumberList){
        System.out.println(num);
    }

    sc.close();
}

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

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

    //有一个集合，里面有1到10 ，现在对1-10累加
    List<Integer> numberList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    //并行化一个集合
    JavaRDD <Integer> numbers = sc.parallelize(numberList);

    //对rdd使用count操作，统计它有多少个元素
    long count = numbers.count();
    System.out.println("count:"+count);

    sc.close();
}

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

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

    //有一个集合，里面有1到10 ，现在对1-10累加
    List<Integer> numberList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    //并行化一个集合
    JavaRDD <Integer> numbers = sc.parallelize(numberList);

    //对rdd使用take操作，
    //take操作与collect类似，也是从远程集群上，获取rdd的数据
    //但是collect是获取rdd的所有数据，take只是获取前n个数据
    List<Integer> top3Number = numbers.take(3);
    for(Integer num :top3Number){
        System.out.println(num);
    }

    sc.close();
}

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

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

    //有一个集合，里面有1到10 ，现在对1-10累加
    List<Integer> numberList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    //并行化一个集合
    JavaRDD <Integer> numbers = sc.parallelize(numberList);

    //使用map操作将集合中的所有数字乘以2
    JavaRDD<Integer> doubleNumber = numbers.map(new Function<Integer, Integer>() {

        private static final long serialVersionUID = 1L;

        @Override
        public Integer call(Integer v) throws Exception {
            return v*2;
        }
    });

    //直接讲rdd中的数据保存在文件中。 
    //但是要注意，我们这里只能指定文件夹，也就是目录
    //但是实际上，会保存为目录中的/double_number/part-00000文件中
    doubleNumber.saveAsTextFile("E://BigData//sparkdata//doule_number");
    sc.close();
}

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

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

    //模拟集合
    List<Tuple2<String, String>> scoreList = Arrays.asList(
            new Tuple2<String, String>("class1", "leo"),
            new Tuple2<String, String>("class2", "tom"),
            new Tuple2<String, String>("class1", "jack"),
            new Tuple2<String, String>("class2", "marry"),
            new Tuple2<String, String>("class2", "david"));

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

    //对rdd应用countByKey操作，统计每个班级的学生人数，也就是统计每个key对应的元素个数
    //这就是countByKey的作用
    //countByKey返回的类型，直接就是Map<String,Object>
    Map<String, Object> studentCounts = students.countByKey();

    for(Map.Entry<String,Object> studentCount :studentCounts.entrySet()){
        System.out.println(studentCount.getKey()+":"+studentCount.getValue());
    }

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

}