1、檔案資料

Spark,100
Hadoop,62
Flink,77
Kafka,91
Hadoop,93
Spark,78
Hadoop,69
Spark,98
Hadoop,62
Spark,99
Hadoop,61
Spark,70
Hadoop,75
Spark,88
Hadoop,68
Spark,90
Hadoop,61

2、Scala程式碼：

package topN

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object GroupTop {
  def main(args: Array[String]): Unit = {

    /**
      * 判斷引數的多少
      */

    if (args.length < 2){
      println(
        """
          |topN.GroupTop<inputPath><outputPath>
          |<inputPath> 檔案輸入目錄
          |<outputPath> 輸出目錄
        """.stripMargin
      )
      System.exit(0)
    }
    /**
      * 接收引數
      */


    val Array(inputPath,outputPath) = args
    /**
      * 初始化程式入口
      */
    val conf = new SparkConf()
    conf.setAppName(s"${this.getClass.getSimpleName}")
    conf.setMaster("local")
    conf.set("spark.serializer","org.apache.spark.serializer.KryoSerializer")

    /**
      * 計算topN
      */
    val sc = new SparkContext(conf)
    val lines: RDD[String] = sc.textFile(inputPath)
    //拆分為Tuple2
    val tupleRDD: RDD[(String, Int)] = lines.map(line => {
      (line.split(",")(0), line.split(",")(1).toInt)
    })
    //分組
    val groutRDD: RDD[(String, Iterable[Int])] = tupleRDD.groupByKey()
    //針對分組對value排序,返回Tuple2
    val groupSort: RDD[(String, List[Int])] = groutRDD.map(grouped => {
      (grouped._1, grouped._2.toList.sortWith(_ > _).take(5))//升序，取Top3
    })
    //遍歷輸出
    groupSort.sortByKey().collect().foreach(pair => {
      println(pair._1+":")
      pair._2.foreach(s => println(s + "\t"))
    })

    sc.stop()
  }
}
 

執行結果：

Flink:
77	
Hadoop:
93	
75	
69	
68	
62	
Kafka:
91	
Spark:
100	
99	
98	
90	
88	

3、Java程式碼：

package topN;

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.api.java.function.VoidFunction;
import org.apache.spark.rdd.RDD;
import scala.Tuple2;

import java.util.Comparator;
import java.util.Iterator;


public class GroupTopN {
    public static void main(String[] args) {

        /**
         * 判斷引數的個數
         */
        if (args.length > 2){
            System.out.println("topN.GroupTopN" +
                    "need two parameter <inputPath><outputPath> \n" +
                    "<inputPath> 輸入路徑\n" +
                    "<outputPath> 輸出路徑");
            System.exit(0);
        }
        /**
         * 接收引數
         */
        String inputPath = args[0];
        String outputPath = args[1];
        SparkConf conf = new SparkConf().setAppName("topN.GroupTopN").setMaster("local");;
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<String> lines = sc.textFile(inputPath);
        
        //拆分為JavaPairRDD程式碼 匿名內部類
        JavaPairRDD<String, Integer> cs = lines.mapToPair(new PairFunction<String, String, Integer>() {

            @Override
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2(s.split(",")[0],Integer.valueOf(s.split(",")[1]));
            }
        });
        //拆分為JavaPairRDD程式碼 用lamda表示式
//        JavaPairRDD cs = lines.mapToPair((PairFunction) s -> new Tuple2(s.toString().split(",")[0],Integer.valueOf(s.toString().split(",")[1])));

        //根據Key分組
        JavaPairRDD<String, Iterable<Integer>> csPairsRDD = cs.groupByKey();
        //根據Key排序，降序
        JavaPairRDD<String, Iterable<Integer>> sortbykey = csPairsRDD.sortByKey();

        //遍歷取出Top3
        sortbykey.foreach(new VoidFunction<Tuple2<String, Iterable<Integer>>>() {
            @Override
            public void call(Tuple2<String, Iterable<Integer>> csPair) throws Exception {
                String name = csPair._1();
                Iterator<Integer> ite = csPair._2().iterator();
                Integer[] res = new Integer[3];
                //排序，取出Top3
                while (ite.hasNext()){
                    Integer score = ite.next();
                    for (int i = 0; i < 3; i++){
                        if (res[i] == null){
                            res[i] = score;
                            break;
                        } else if (res[i] < score){
                            for (int j= 2 ; j > i; j--){
                                res[i] = res[j - 1];
                            }
                            res[i] = score;
                            break;
                        }
                    }
                }
                System.out.println(name+":");
                for (int i = 0; i < res.length; i++){
                    System.out.println(res[i] + "\t");
                }
                System.out.println();
            }


        });
        sc.close();
    }

}
 

執行結果：

Flink:
77	
null	
null	

Hadoop:
93	
75	
68	

Kafka:
91	
null	
null	

Spark:
100	
99	
90