Spark之TopN

package com.uplooking.bigdata.core.p3;
 
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.PairFunction;
import org.apache.spark.broadcast.Broadcast;
import scala.Tuple2;
 
import java.util.List;
import java.util.TreeSet;
 
/**
 * Java版本求出TopN的数据
 学生所在班级 学生成绩
     class1 90
     class2 56
     class1 90
     class1 76
     class2 88
     class1 95
     class1 74
     class2 87
     class2 67
     class2 77
     class1 98
     class2 96
 要求，求出成绩前五名（N=5）的同学，想求出N=3的同学的信息
 
 第二题：
    在上述的基础之上进行修正，分别求出每个班级中排名前3的同学的信息
 */
public class JavaSparkTopNOps {
    public static void main(String[] args) {
        if(args == null || args.length < 1) {
            System.err.println("Parameter Errors! Usage: ");
            System.exit(-1);
        }
        SparkConf conf = new SparkConf();
        conf.setAppName(JavaSparkTopNOps.class.getSimpleName());
        conf.setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD linesRDD = sc.textFile("E:/test/spark/topn.txt");
        int topNum = Integer.valueOf(args[0].trim());
        //第一题
//        topn_1(linesRDD, topNum);
        //第二题
        Broadcast topNBC = sc.broadcast(topNum);
        topn_2(linesRDD, topNBC);
        sc.close();
    }
 
    /**
     * 分组topN
     * 分别求出每个班级中排名前N的同学的信息
     *
     * 按照班级名称，对班级学生进行分组，分组之后可以得到每一个分组中的数据，然后再来对每一个组中的数据进行排序
     * 只需要取出这每一个组中的前N名的学生信息即可
     * 在这里显然要是用groupByKey的transformation算子
     * hello you
     * hello me
     * hello me
     * mapToPair之后的结果
     * (hello, 1)
     * (you, 1)
     * (hello, 1)
     * (me, 1)
     * (hello, 1)
     * (me, 1)
     * groupByKey--->
     * (hello, [1, 1, 1])
     * (you, [1])
     * (me, [1, 1])
     * 类比到我们这道题，我们只需要控制hello，me，you后面的列表的size就可以了
     * @param linesRDD
     */
    private static void topn_2(JavaRDD linesRDD, Broadcast topNBC) {
        JavaPairRDD pairRDD = linesRDD.mapToPair(line -> {
            String[] splits = line.split(" ");
            int score = Integer.valueOf(splits[1].trim());
            String className = splits[0].trim();
            return new Tuple2(className, score);
        });
 
        JavaPairRDD> gbkRDD = pairRDD.groupByKey();
        //class1 [90, 90, 76]
        //class2 [56, 88, 87]
        JavaPairRDD> myGbkRDD = gbkRDD.mapToPair(new PairFunction>, String, Iterable>() {
            private TreeSet ts = new TreeSet(new MyComparator(){
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2 - o1;
                }
            });
            @Override
            public Tuple2> call(Tuple2> src) throws Exception {
                String className = src._1;
                Iterable scores = src._2;
                ts.clear();
                /**
                 * 第一步对这个列表scores进行排序
                 * 第二步然后取出这个列表中的前N个值，组成一个新的Iterable
                 */
                for(int score : scores) {
                    ts.add(score);//将数据加入到treeset集合中
                    if(ts.size() > topNBC.value()) {//加入集合之后对集合的大小进行判断，因为我们只需要求出TopN（N=3），所以只需要维持treeset集合大小为N即可
                        ts.pollLast();
                    }
                }
                return new Tuple2>(className, ts);
            }
        });
 
        myGbkRDD.foreach(t -> System.out.println(t._1 + " " + t._2));
    }
 
    private static void topn_1(JavaRDD linesRDD, int topNum) {
        JavaPairRDD pairRDD = linesRDD.mapToPair(line -> {
            String[] splits = line.split(" ");
            int score = Integer.valueOf(splits[1].trim());
            String className = splits[0].trim();
            return new Tuple2(score, className);
        });
 
        List> topn = pairRDD.sortByKey(false).take(topNum);
        for (Tuple2 t : topn) {
            System.out.println("className: " + t._2 + ", score: " + t._1);
        }
    }
 
}