Spark基于排序机制的wordcount程序（Java版）

1，需求分析
前面我们已经学习Spark常用transformation和action的操作。那么现在问题来了，文本文件内的每个单词都出现几次？可否按照每个单词出现的次数排序？下面我们就来解决这个问题。

2，实验准备
2.1. Java开发工具eclipse
2. 2.spark-1.6.0-bin-hadoop2.6

3，编码实战
3.1. 在eclipse新建java项目spark-learn，并新建包com.spark.midea，和类SortWordCount。如下图。

3.2.创建SparkConf和JavaSparkContext。

SparkConf conf = new SparkConf()
                .setAppName("SortWordCount")
                .setMaster("local"); 
        JavaSparkContext sc = new JavaSparkContext(conf);

3.3.创建lines RDD。

JavaRDD<String> lines = sc.textFile("C://Users//Administrator//Desktop//spark.txt");

3.4.执行单词计数。

JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {

            private static final long serialVersionUID = 1L;

            @Override
            public Iterable<String> call(String t) throws Exception {
                return Arrays.asList(t.split(" "));}  
    });
JavaPairRDD<String, Integer> pairs = words.mapToPair(

                new PairFunction<String, String, Integer>() {

                    private static final long serialVersionUID = 1L;

                    @Override
                    public Tuple2<String, Integer> call(String t) throws Exception {
                        return new Tuple2<String, Integer>(t, 1);
                    }

                });

        JavaPairRDD<String, Integer> wordCounts = pairs.reduceByKey(

                new Function2<Integer, Integer, Integer>() {

                    private static final long serialVersionUID = 1L;

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

                });     

3.5.进行key-value的反转映射。

JavaPairRDD<Integer, String> countWords = wordCounts.mapToPair(

                new PairFunction<Tuple2<String,Integer>, Integer, String>() {

                    private static final long serialVersionUID = 1L;

                    @Override
                    public Tuple2<Integer, String> call(Tuple2<String, Integer> t)
                            throws Exception {
                        return new Tuple2<Integer, String>(t._2, t._1);
                    }

                });

3.6.按照key进行排序。

JavaPairRDD<Integer, String> sortedCountWords = countWords.sortByKey(false);

3.7.再次将value-key进行反转映射。

JavaPairRDD<String, Integer> sortedWordCounts = sortedCountWords.mapToPair(

                new PairFunction<Tuple2<Integer,String>, String, Integer>() {

                    private static final long serialVersionUID = 1L;

                    @Override
                    public Tuple2<String, Integer> call(Tuple2<Integer, String> t)
                            throws Exception {
                        return new Tuple2<String, Integer>(t._2, t._1);
                    }

                });

3.8.打印出最终结果。

sortedWordCounts.foreach(new VoidFunction<Tuple2<String,Integer>>() {

            private static final long serialVersionUID = 1L;

            @Override
            public void call(Tuple2<String, Integer> t) throws Exception {
                System.out.println(t._1 + " appears " + t._2 + " times.");      
            }

        });

3.9.关闭JavaSparkContext，到这一步，问题圆满解决。

sc.close();

4，总结
动手敲熟练Spark常用transformation和action的操作后，如果能自行编码解决排序机制的wordcount程序，那么对transformation和action的理解就上了个台阶！