大数据IMF传奇行动绝密课程第20课：Top N彻底解秘

Top N彻底解秘

1、基础top N算法
2、分组top N算法

只要是改变每一行列的数据，一般都是用map操作，下面是基础topN算法。

package com.tom.spark.cores

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

/**
  * TopNBasic.scala
  */
object TopNBasic {
  def main(args: Array[String]) {
    val conf = new SparkConf().setAppName("Top N Basically!").setMaster("local")
    val sc = new SparkContext(conf)

// 以下注释内容因为得到的top5不是RDD（take不返回RDD），所以重新写了能得到RDD的
//    val lines = sc.textFile("F:\\sparkData\\basicTopN.txt")
//    val pairs = lines.map(line => (line.toInt, line)) //生成Key-Value键值对以方便sortByKey进行排序,Int已经实现了排序比较的接口
//    val sortedPairs = pairs.sortByKey(false) //降序排序
//    val sortedData = sortedPairs.map(_._2)  //过滤出排序后的内容本身
//    val top5 = sortedData.map(_.take(5))  //获取排名前5位的元素内容,元素内容构建成为一个Array

        val lines = sc.textFile("F:\\sparkData\\basicTopN.txt")
        val top5 = lines.map(line => ("tmpKey", line)).groupByKey().flatMap(_._2.toList.sortWith(_ > _).take(5))

    top5.collect().foreach(println)
  }

}

找出每种类型数据中的topN

先按类型分组，然后再排序

//Java实现
/**
 * 
 */
package com.tom.spark.SparkApps.cores;

import java.util.Arrays;
import java.util.Iterator;

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 scala.Tuple2;

/**
 * 使用java开发topN程序
 *
 */
public class TopNGroup {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SparkConf conf = new SparkConf().setAppName("Top N Group").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);
        JavaRDD<String> lines = sc.textFile("F:\\sparkData\\topNGroup.txt");
        //把每行数据变成符合要求的<Key,Value>格式
        JavaPairRDD<String, Integer> pairs = lines.mapToPair(new PairFunction<String, String, Integer>() {

            /**
             * 
             */
            private static final long serialVersionUID = 1L;

            public Tuple2<String, Integer> call(String line) throws Exception {
                // TODO Auto-generated method stub
                String[] splitedLine = line.split(" ");

                return new Tuple2<String, Integer>(splitedLine[0], Integer.valueOf(splitedLine[1]));
            }
        });
        JavaPairRDD<String, Iterable<Integer>> groupedPairs = pairs.groupByKey(); //对数据进行分组

        JavaPairRDD<String, Iterable<Integer>> top5 = groupedPairs.mapToPair(new PairFunction<Tuple2<String,Iterable<Integer>>, String, Iterable<Integer>>() {

            /**
             * 
             */
            private static final long serialVersionUID = 1L;

            public Tuple2<String, Iterable<Integer>> call(
                    Tuple2<String, Iterable<Integer>> groupedData) throws Exception {
                // TODO Auto-generated method stub
                Integer[] top5 = new Integer[5]; //保存top5的数据本身
                String groupedKey = groupedData._1; //获取分组的组名
                Iterator<Integer> groupedValue = groupedData._2.iterator(); //获取每组的内容集合
                while(groupedValue.hasNext()) { //查看是否有下一个元素，如果继续进行循环
                    Integer value = groupedValue.next(); //获取当前循环元素本身的内容
                    for(int i = 0; i < 5; i++) { //具体实现分组内部的topN
，采用冒泡排序
                        if(top5[i] == null) {
                            top5[i] = value;
                            break;
                        }
                        else if(value > top5[i]) {
                            for(int j = 4; j > i; j--) {
                                top5[j] = top5[j - 1]; 
                            }
                            top5[i] = value;
                            break;
                        }
                    }
                }
                return new Tuple2<String, Iterable<Integer>>(groupedKey, Arrays.asList(top5));
            }
        });

        //打印分组后的Top N
        top5.foreach(new VoidFunction<Tuple2<String,Iterable<Integer>>>() {

            /**
             * 
             */
            private static final long serialVersionUID = 1L;

            public void call(Tuple2<String, Iterable<Integer>> topped) throws Exception {
                // TODO Auto-generated method stub
                System.out.print("Group key : " + topped._1 + " : "); //获取Group Key
                Iterator<Integer> toppedValue = topped._2.iterator(); //获取Group Value
                while(toppedValue.hasNext()) { //具体打印出每组的Top N
                    Integer value = toppedValue.next();
                    System.out.print(value+ " ");
                }
                System.out.println();

            }
        });

        sc.close();
    }

}

//scalas实现
package com.tom.spark.cores

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

/**
  * 
  */
object TopNGroup {
  def main(args: Array[String]) {
    val conf = new SparkConf().setAppName("Top N Basically!").setMaster("local")
    val sc = new SparkContext(conf)

    val lines = sc.textFile("F:\\sparkData\\topNGroup.txt")
    val pairs = lines.map(line => {
      val splited = line.split(" ")
      (splited(0),splited(1).toInt)
    }) //生成Key-Value键值对以方便sortByKey进行排序,Int已经实现了排序比较的接口
    val groupedPairs = pairs.groupByKey() //降序排序

    val sortedPairs = groupedPairs.sortByKey().map(pair =>
      (pair._1,pair._2.toList.sortWith(_ > _).take(5)))

    sortedPairs.collect().foreach(pair => {
      println(pair._1 + " : " + pair._2)
    })

  }
}

RangePartitioner

RangePartitioner主要是把依赖的RDD的数据分成不同的范围，关键的是不同的范围是有序的

Google的面试题：如何在一个不确定数据规模的范围内进行排序
水塘抽样：从集合中选取具体个数的样本。适合于内存容纳不下的数据量。
N很大，从N中K个抽样的数据。

RangePartitioner就是采用了这个水塘抽样的方法

在1.1版本以前，sortByKey会触发两个job，现在只触发一个job

HashPartitioner弊端，数据倾斜，极端情况下某（几）个分区拥有RDD的所有数据！

RangePartitioner除了是结果有序的基石以外，最为重要的是尽量保证每个Partition中的数据量是均匀的
下面是采样：
val sampleSizePerPartition = math.ceil(3.0 * sampleSize / rdd.partitions.size).toInt
依赖的RDD可能数据不均匀，乘3的目的是数据量特别少的分区能抽取到足够的数据，同时保证数据量特别大的分区能够二次采样
sketch中
(Long, Array[(Int, Long, Array[K])])
Int 分区编号, Long 分区中总元素的个数， Array[K]从副RDD中每个分区中采样到的数据
reservoirSampleAndCount水塘采样
返回：(reservoir, l) 其中l记录了分区中的元素的总和
重新采样的情况：
if (fraction * n > sampleSizePerPartition) {
imbalancedPartitions += idx
}
确定具体的Key属于哪个分区partition = binarySearch(rangeBounds, k)