挑战全网比较全的spark求topN的思路（java、scala）

• java版本:

1、自定义实现排序key，实现Ordered接口，根据指定的排序条件，重写compare 、less、greater等方法，封装多个字段进行排序;

　　

// 代码示例其中CategorySortKey为自定义的key

 JavaPairRDD<CategorySortKey, String> sortedCategoryCountRDD = sortKey2countRDD.sortByKey(false);

public class CategorySortKey implements Ordered<CategorySortKey>, Serializable {
    
    private static final long serialVersionUID = -6007890914324789180L;
    
    private long clickCount;
    private long orderCount;
    private long payCount;
    
    public CategorySortKey(long clickCount, long orderCount, long payCount) {
        this.clickCount = clickCount;
        this.orderCount = orderCount;
        this.payCount = payCount;
    }

    @Override
    public boolean $greater(CategorySortKey other) {
        if(clickCount > other.getClickCount()) {
            return true;
        } else if(clickCount == other.getClickCount() && 
                orderCount > other.getOrderCount()) {
            return true;
        } else if(clickCount == other.getClickCount() &&
                orderCount == other.getOrderCount() &&
                payCount > other.getPayCount()) {
            return true;
        }
        return false;
    }

    @Override
    public boolean $greater$eq(CategorySortKey other) {
        if($greater(other)) {
            return true;
        } else if(clickCount == other.getClickCount() &&
                orderCount == other.getOrderCount() &&
                payCount == other.getPayCount()) {
            return true;
        }
        return false;
    }
    
    @Override
    public boolean $less(CategorySortKey other) {
        if(clickCount < other.getClickCount()) {
            return true;
        } else if(clickCount == other.getClickCount() && 
                orderCount < other.getOrderCount()) {
            return true;
        } else if(clickCount == other.getClickCount() &&
                orderCount == other.getOrderCount() &&
                payCount < other.getPayCount()) {
            return true;
        }
        return false;
    }

    @Override
    public boolean $less$eq(CategorySortKey other) {
        if($less(other)) {
            return true;
        } else if(clickCount == other.getClickCount() &&
                orderCount == other.getOrderCount() &&
                payCount == other.getPayCount()) {
            return true;
        }
        return false;
    }

    @Override
    public int compare(CategorySortKey other) {
        if(clickCount - other.getClickCount() != 0) {
            return (int) (clickCount - other.getClickCount());
        } else if(orderCount - other.getOrderCount() != 0) {
            return (int) (orderCount - other.getOrderCount());
        } else if(payCount - other.getPayCount() != 0) {
            return (int) (payCount - other.getPayCount());
        }
        return 0;
    }
    
    @Override
    public int compareTo(CategorySortKey other) {
        if(clickCount - other.getClickCount() != 0) {
            return (int) (clickCount - other.getClickCount());
        } else if(orderCount - other.getOrderCount() != 0) {
            return (int) (orderCount - other.getOrderCount());
        } else if(payCount - other.getPayCount() != 0) {
            return (int) (payCount - other.getPayCount());
        }
        return 0;
    }

    public long getClickCount() {
        return clickCount;
    }

    public void setClickCount(long clickCount) {
        this.clickCount = clickCount;
    }

    public long getOrderCount() {
        return orderCount;
    }

    public void setOrderCount(long orderCount) {
        this.orderCount = orderCount;
    }

    public long getPayCount() {
        return payCount;
    }

    public void setPayCount(long payCount) {
        this.payCount = payCount;
    }  
    
}

2、通过一些计算方式，获取到封装的实体类集合，然后利用java8的多条件排序（thenComparing）;

 

3、若是想获取每个领域的topN:（如想获取每个班级的top10的数学成绩的同学姓名）

　　A、先声明长度为N的数组，然后一个个去进行比较，然后数组移位，用大的替换小的；

// 此代码是rdd操作的一部分，如foreach算子，每一个tuple2都会执行、
long categoryid = tuple._1;
            Iterator<String> iterator = tuple._2.iterator();

            // 定义取topn的排序数组
            String[] top10Sessions = new String[10];

            while (iterator.hasNext()) {
              String sessionCount = iterator.next();
              long count = Long.valueOf(sessionCount.split(",")[1]);

              // 遍历排序数组
              for (int i = 0; i < top10Sessions.length; i++) {
                // 如果当前i位，没有数据，那么直接将i位数据赋值为当前sessionCount
                if (top10Sessions[i] == null) {
                  top10Sessions[i] = sessionCount;
                  break;
                } else {
                  long _count = Long.valueOf(top10Sessions[i].split(",")[1]);

                  // 如果sessionCount比i位的sessionCount要大
                  if (count > _count) {
                    // 从排序数组最后一位开始，到i位，所有数据往后挪一位
                    for (int j = 9; j > i; j--) {
                      top10Sessions[j] = top10Sessions[j - 1];
                    }
                    // 将i位赋值为sessionCount
                    top10Sessions[i] = sessionCount;
                    break;
                  }

                  // 比较小，继续外层for循环
                }
              }
            }

• scala版本：

1、可将要排序的值形成一个tuple2的mapRDD，然后执行rdd的sortBy(_._2);

2、通过一些计算方式，获取到封装的实体类集合，利用将 value 转换为数组，sortWith(lt : scala.Function2[A,A,scala.Boolean])进行指定方式排序;

3、若是想获取每个领域的topN:（如想获取每个班级的top10的数学成绩的同学姓名）

　　A、先声明长度为N的数组，然后一个个去进行比较，然后数组移位，用大的替换小的。（此方式与java版本一致）；

　　B、scala：（1）按照key 对数据进行聚合（groupByKey）（2）将 value 转换为数组，利用 scala 的 sortBy 或者sortWith进行排序（mapValues），但是数据量太大会OOM。

 

    //    (省份，[(广告A，sum),(广告B，sum),(广告C，sum)])
    val groupRDD: RDD[(String, Iterable[(String, Int)])] = newMapRDD.groupByKey()

    //   将分组后的数据组内排序（降序），取前三名
    //保持key不变，对value进行操作，使用mapValues
    //降序(List)：(Ordering.Int.reverse)
    val resultRDD: RDD[(String, List[(String, Int)])] = groupRDD.mapValues(
      iter => {
        iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
      }
    )

 

　　C、弥补上个方案的缺点：此时可以拆解上述步骤：（1）取出所有的 key （2）对 key 进行迭代，每次取出一个 key 利用 spark 的排序算子进行排序

 //    (省份1，(广告A，sum1))、 (省份1，(广告B，sum2))
 //    (省份2，(广告A，sum3))、 (省份2，(广告B，sum4))
    val provinces: Array[String] = subTeacherAndOne.map(_._1).distinct().collect()

    for (province <- provinces){
      // 按照学科将数据进行过滤出来
      val filtered: RDD[((String, String), Int)] = subTeacherAndOne.filter(t => t._1.equals(province))
      // RDD的takeOrdered方法,可以设置排序规则,并指定取前几个值
      val res: Array[((String, String), Int)] = filtered.takeOrdered(2)((a, b) => a._2._2 - b._2._2)
      // 打印结果
      println(res.toBuffer)
    }

　　D、使用自定义分区器取TopN

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

import scala.collection.mutable

/**
 * 使用自定义分区器取topn,可以将较大的数据按照分区加载到内存中进行排序取topn,这样减小了
 * 内存的压力,同时也加快了数据,但是如果某个分区中的数据量过大的话,这个方法就不适用了
 */
object Teacher03 {
  def main(args: Array[String]): Unit = {
    // 创建配置参数对象,进行参数配置
    val conf = new SparkConf().setAppName(this.getClass.getSimpleName)
    var isLocal:Boolean = args(0).toBoolean
    if(isLocal){
      conf.setMaster("local[*]")
    }
    // 创建Spark入口
    val sc = new SparkContext(conf)
    // 读取文件
    val lines: RDD[String] = sc.textFile(args(1))
    // 对数据进行切分聚合处理
    val subTeacherAndOne: RDD[((String, String), Int)] = lines.map(line => {
      val strArr = line.split("/")
      val url: String = strArr(2)
      val teacher: String = strArr(3)
      val subject = url.substring(0, url.indexOf("."))
      ((subject, teacher), 1)
    }).reduceByKey(_ + _)
    // 将学科信息收集到客户端
    val subjects: Array[String] = subTeacherAndOne.map(_._1._1).distinct().collect()
    // 根据自定义的分区器进行分区,有几个学科就有几个分区
    val partitioned: RDD[((String, String), Int)] = subTeacherAndOne.partitionBy(new SubjectPartitioner(subjects))
    // 使用mapPartition进行区内排序取topn
    val res: RDD[((String, String), Int)] = partitioned.mapPartitions(t => {
      val it = t.toList.sortBy(_._2).take(2).iterator
      it
    })
    // 打印结果
    println(res.collect().toBuffer)
    // 释放资源
    sc.stop()
  }
}

/**
 * 自定义分区器在创建好对象后,task会去执行里面的方法,getPartition(key: Any)这个方法
 * 中的key,task会根据自己设定的key.asInstanceOf的类型,进行匹配对应的类型
 * @param subjects
 */
class SubjectPartitioner(subjects : Array[String]) extends Partitioner {
  // 设置分区规则,按照学科指定分区
  private val ruels = new mutable.HashMap[String, Int]()
  var i:Int = 0
  // 将指定每个学科归属哪个分区
  for (sub <- subjects){
    ruels(sub) = i
    i += 1
  }

  // 重写指定分区数量的方法
  override def numPartitions: Int = subjects.length

  // 重写获取分区的方法
  override def getPartition(key: Any): Int = {
    val subject: String = key.asInstanceOf[(String, String)]._1
    ruels(subject)
  }
}