spark分组求topN

最新推荐文章于 2023-07-04 20:07:29 发布
最新推荐文章于 2023-07-04 20:07:29 发布
阅读量490 收藏 1
点赞数
分类专栏： spark 
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39674417/article/details/111360127
版权
本文详细介绍了在Spark中实现分组求TopN的多种方法，包括：将数据加载到内存中去TopN、使用自定义分区器取TopN、保存中间结果数据取TopN以及使用TreeSet取TopN。通过实例代码展示了如何处理大规模数据集，并讨论了不同方法的适用场景和优缺点。
摘要由CSDN通过智能技术生成

目录

1. 将数据加载到内存中去TopN

将数据加载到内存和本地中去取TopN

使用自定义分区器取TopN

保存中间结果数据取TopN

使用TreeSet取TopN

使用TreeSet取TopN方式二

在mr、hive中投处理过的操作，分组的topn

​    比如要从10个文件，每个文件都有100w个数字，找出最大的10数字。

​    比如有很多部分，比如研发部、设计部、市场部、行政部等等，要求找出每个部分年龄最小的三个小姐姐。

​    这就是分组TopN的问题。

object _03SparkGroupTopNOps {
def main(args: Array[String]): Unit = {
val conf = new SparkConf()
.setAppName(s"${_01SparkSortOps.getClass.getSimpleName}")
.setMaster(“local[2]”)
val sc = new SparkContext(conf)

    val lines = sc.textFile("file:///E:/data/spark/topn.txt")

    val course2Info:RDD[(String, String)] = lines.map(line => {
        val fields = line.split("\\s+")
        val course = fields(0)
        val name = fields(1)
        val score = fields(2)
        (course, s"$name|$score")
    })
    //就需要将每门课程的所有信息弄到一起才能排序
    val course2Infos:RDD[(String, Iterable[String])] = course2Info.groupByKey()
    /*
        排序
           k，是科目
           v：该科目对应的所有的成绩信息
           经过排序之后返回三个人的成绩信息，还是一个集合
           [k, Iterable[String]] --> [k, Iterable[String]]只不过后面Iterable[String]的size为3
           还是one-2-many的操作
           one-2-one--->map
     */
    val top3:RDD[(String, mutable.TreeSet[String])] = course2Infos.map{case (course, infos) => {
        var top3Infos = mutable.TreeSet[String]()(new Ordering[String](){
            //name|score
            override def compare(x: String, y: String) = {
                val xScore = x.substring(x.indexOf("|") + 1).toInt
                val yScore = y.substring(y.indexOf("|") + 1).toInt
                var ret = xScore.compareTo(yScore)
                if(ret == 0) {
                    1
                } else {
                    ret
                }
            }
        })

        //排序的操作 top3Infos是有序的，但是最后只要3个
// top3Infos.dropRight(top3Infos.size - 3)
for(info <- infos) {
top3Infos.add(info)
if(top3Infos.size > 2) {
top3Infos = top3Infos.dropRight(1)
}
}
(course, top3Infos)
}}

1. 将数据加载到内存中去TopN

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

/**
 * 将数据加载到内存中进项排序取topn
 */
object Teacher01 {
  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(_ + _)
    // 因为SortBy是全局进行排序,所以不能直接使用,先要进行进行分组,在进行组内排序
    val grouped: RDD[(String, Iterable[((String, String), Int)])] = subTeacherAndOne.groupBy(_._1._1)
    // 组内进行排序
    val res: RDD[(String, List[(String, Int)])] = grouped.mapValues(it => {
      // 将数据加载到内存中
      it.toList.sortBy(-_._2).take(2).map(t => (t._1._2, t._2))
    })
    // 将结果收集到客户端,打印
    val buffer = res.collect().toBuffer
    println(buffer)
    // 释放资源
    sc.stop()
  }
}

将数据加载到内存和本地中去取TopN

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

/**
 * 代码优化,如果将数据全部加载到内存中进行处理,如果数据量过大,可能会导致
 * 内存溢出,数据丢失,使用RDD的sortBy方法进行排序可以将数据加载到内存和
 * 磁盘中
 */
object Teacher02 {
  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("bigdata", "javaee", "php")
    // 对应数组中的学科学科进行过滤排序(等同于分组排序)
    for (sub <- subjects){
      // 按照学科将数据进行过滤出来
      val filtered: RDD[((String, String), Int)] = subTeacherAndOne.filter(t => t._1._1.equals(sub))
      // RDD的takeOrdered方法,可以设置排序规则,并指定取前几个值
      val res: Array[((String, String), Int)] = filtered.takeOrdered(2)((a, b) => a._2 - b._2)
      // 打印结果
      println(res.toBuffer)
    }
    sc.stop()
  }
}

使用自定义分区器取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)
  }
}

保存中间结果数据取TopN

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

import scala.collection.mutable

/**
 *使用自定义分区器取topn,上一种写法存在着不足,因为如果中间结果数据比较珍贵,并且是经过了多天的计算得出的结果
 *那么在计算过程中,如果计算机出了问题,那就会导致多天的计算毁于一旦,所以可以将中间结果数据保存到hfds中,这样
 *可以增加数据的安全性
 */
object TeacherTopN4 {

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

    val isLocal = args(0).toBoolean


    val conf = new SparkConf().setAppName(this.getClass.getSimpleName)

    if(isLocal) {
      conf.setMaster("local[*]")
    }

    val sc = new SparkContext(conf)

    //指定以后从哪里读取数据创建RDD
    val lines = sc.textFile(args(1))

    //对数据进行切分整理
    val subjectTeacherAndOne: RDD[((String, String), Int)] = lines.map(line => {
      val fields = line.split("/")
      val url = fields(2)
      val teacher = fields(3)
      val subject = url.substring(0, url.indexOf("."))
      ((subject, teacher), 1)
    })

    //先触发一次Action，将学科的数量计算出来，将计算好的结果收集到Driver端
    val subjects: Array[String] = subjectTeacherAndOne.map(_._1._1).distinct().collect()

    val reduced = subjectTeacherAndOne.reduceByKey(new SubjectPartitioner2(subjects), _ + _)
    // 将数据保存到hdfs中
    reduced.saveAsTextFile(args(2))

    val res: RDD[((String, String), Int)] = reduced.mapPartitions(it => {
      it.toList.sortBy(-_._2).take(2).iterator
    })
    println(res.collect().toBuffer)

    sc.stop()
  }

}

class SubjectPartitioner2(val subjects: Array[String]) extends Partitioner {

  //学科名称 -> 分区编号
  val rules = new mutable.HashMap[String, Int]()
  var i = 0
  for (sub <- subjects) {
    rules(sub) = i
    i += 1
  }

  override def numPartitions: Int = subjects.length

  override def getPartition(key: Any): Int = {
    val subject = key.asInstanceOf[(String, String)]._1
    rules(subject)
  }
}

使用TreeSet取TopN

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

import scala.collection.mutable

object TeacherTopN5 {

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

    val isLocal = args(0).toBoolean

    val conf = new SparkConf().setAppName(this.getClass.getSimpleName)

    if(isLocal) {
      conf.setMaster("local[*]")
    }

    val sc = new SparkContext(conf)

    //指定以后从哪里读取数据创建RDD
    val lines = sc.textFile(args(1))

    //
    val topN = args(2).toInt

    //对数据进行切分整理
    val subjectTeacherAndCount = lines.map(line => {
      val fields = line.split("/")
      val url = fields(2)
      val teacher = fields(3)
      val subject = url.substring(0, url.indexOf("."))
      ((subject, teacher), 1)
    }).reduceByKey(_+_)

    //按照学科进行分组
    val grouped: RDD[(String, Iterable[((String, String), Int)])] = subjectTeacherAndCount.groupBy(_._1._1)

    //对迭代器中的数据进行排序
    val res = grouped.mapValues(it => {
        implicit val rules = Ordering[Int].on[((String, String), Int)](t => -t._2)
      val sorter = new mutable.TreeSet[((String, String), Int)]()

      it.foreach(e => {
        //从迭代器中取出来放入到TreeSet
        sorter.add(e)
        if(sorter.size > topN) {
          //移除最小的
          val smallest = sorter.last
          sorter -= smallest
        }
      })
      //保存到treeSet中最终的数据就是想要的结果
      sorter
    })
    println(res.collect().toBuffer)
    sc.stop()
  }
}

使用TreeSet取TopN方式二

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

import scala.collection.mutable

object TeacherTopN6 {

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

    val isLocal = args(0).toBoolean

    val conf = new SparkConf().setAppName(this.getClass.getSimpleName)

    if(isLocal) {
      conf.setMaster("local[*]")
    }

    val sc = new SparkContext(conf)

    //指定以后从哪里读取数据创建RDD
    val lines = sc.textFile(args(1))

    val topN = args(2).toInt

    //对数据进行切分整理
    val subjectTeacherAndCount = lines.map(line => {
      val fields = line.split("/")
      val url = fields(2)
      val teacher = fields(3)
      val subject = url.substring(0, url.indexOf("."))
      ((subject, teacher), 1)
    }).reduceByKey(_+_)

    //按照学科进行分组
    val grouped: RDD[(String, Iterable[((String, String), Int)])] = subjectTeacherAndCount.groupBy(_._1._1)

    //对迭代器中的数据进行排序
    val res = grouped.mapValues(it => {

      val sorter = new mutable.TreeSet[OrderingBean]()

      it.foreach(e => {
        //从迭代器中取出来放入到TreeSet
        sorter += new OrderingBean(e._1._1, e._1._2, e._2)
        if(sorter.size > topN) {
          //移除最小的
          val smallest = sorter.last
          sorter -= smallest
        }
      })
      //保存到treeSet中最终的数据就是想要的结果
      sorter
    })
    println(res.collect().toBuffer)
    sc.stop()
  }
}

以上就是spark中取TopN的多种方式,每个方式都各有特点,具体使用哪一个方式要根据实际情况进行使用,比如说数据量的大小,或者是否对运算速度有明确的要求,具体还是要根据场景进行使用的.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

青龙悟空
关注
专栏目录
Spark实现TopN
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
07-02 1663
大数据实验教学系统练习 Spark实现TopN因为Spark RDD是分区并行计算的，因此要排序的话，需要指定一个分区。   使用sortByKey算子，按key排序，然后再使用take算子，取前几个元素，就得到了 Top N 的结果。掌握抓取文本中最大的前几位数字。   掌握排序算子的使用。1、使用Spark RDD实现 Top N。    假设我们有以下输入文件top.txt： 编写RDD代码，获取值最大的三个数（Top 3）。    2、使用Spark RDD实现分组 Top N。    假设我们有以
Spark 计算 - 实现分组求 TopN
Henvealf的博客
04-25 1228
问题抽象：找出分组内数据的 TopN。 问题实例 找出每个城市(province)应用点击数(click)排前5的人(name)。这里假定省内每个人的点击数以及计算好了。 思路 思路: 这里的名字只是附属属性，求每个省份最高的5个点击数即可。首先按照省份分组，在组内聚合求 top 5参考 top() 算子的实现方法，使用一个有固定长度（这里即5）的优先队列，每个组内迭代将元素add进优先队列中，最...
pandas根据列名提取数据_Python学习100天-Day15(数据分析篇-pandas03）
weixin_39800957的博客
11-27 281
Day15-数据框筛选和排序先解答一下昨天的问题，假如现在2013NBA的数据是这样：C和SG的数据分了出来，我们现在要通过pandas操作合并sheet。我这边定于了一个合并sheet的方法，名为bindsheet，返回的是DF对象：alldata。可以直接调用方法然后填入文件地址参数进行合并。通过定义bindsheet方法，方便我们将方法运用在合并xlsx文件的代码中，可以通过先合并sheet...
Spark分组取TopN
SunnyRivers
05-12 1583
前言 说到分组，我们很快就想到group by，但是如果在分组的基础上进行取TopN，我们很快又想到开窗函数，group by一般和聚合函数搭配使用，那么聚合函数和开窗函数有啥区别呢？ 普通的聚合函数聚合的行集是组,开窗函数聚合的行集是窗口。因此,普通的聚合函数每组(Group by)只返回一个值，而开窗函数则可为窗口中的每行都返回一个值。简单理解，就是对查询的结果多出一列，这一列可以是聚合值，...
Spark实现分组排序TopN
Mcharleylei的博客
06-02 1688
分组排序TopN的第一种实现方式 （1）思路：先将rdd转换为key/value键值对类型的rdd，然后按照key对数据进行聚合，对同组key的所有value数据进行排序，对排序之后的value集合获取出现次数最多的前3个数据 // 缺点1：groupByKey这个API在现在这个版本的实现中，同组(相同key)的所有value全部加载到内存进行处理，当value特别多的时候就有可能出现OOM异常 // 缺点2：在对同组key数据进行聚合操作的业务场景中，groupByKey的性能有点低，groupB.
JavaSpark | RDD实战：分组top n
liujiesxs的博客
07-22 550
分组top n -- javaSaprk
Spark Core 和 Spark SQL 实现分组取Top N(基于scala)
wftt的博客
07-05 5978
分组取Top N在日常需求中很多见： 每个班级分数前三名同学的名字以及分数 各省指标数量前三的市的名字 等等需求，主要思想就是在某一个分区（班级，省）中取出该分区Top N的数据 测试数据格式： 如上图，字段含义为，班级，学生姓名，分数 下面我们通过一个Demo来实现各班级分数前三的学生姓名以及分数 1、通过Spark core 实现： //读取测试数据保存为rdd ...
大数据实验报告Spark编程实现TopN和InvertedIndex程序.doc
12-15
Spark 编程实现 TopN 和 InvertedIndex 程序 在大数据实验报告中，我们使用 Spark 编程实现了 TopN 和 InvertedIndex 程序。这些程序都是基于 Scala 语言的，利用了 Spark 的强大功能来进行数据处理和分析。 TopN ...
spark实现TopN
10-24
spark实现分组求和
Spark-分组TOPN算法
刷穿算法！！！！
12-22 295
该数据集都为：“http://bigdata.edu360.cn/laozhou” 这个样子，需求是找到每个学科下最受欢迎的老师 方法一： /** * 数据放到scala 集合里面进行操作 */ object GroupFavTeacher_1 { def main(args: Array[String]): Unit = { val conf = new SparkConf(...
spark分组取topN
我是60岁程序员
11-15 422
准备数据： aa 11 bb 11 cc 34 aa 22 bb 67 cc 29 aa 36 bb 33 cc 30 aa 42 bb 44 cc 49 import org.apache.spark.{SparkConf, SparkContext} /** * @author zoujc * @date 2018/11/15 */ object topN { def main...
Spark-分组TopN
qq_40382400的博客
07-04 464
Spark的分组TopN （1）自定义分区器，按照key进行分区，使不同的key进到不同的分区 （2）对每个分区运用spark的排序算子进行排序// 构造示例数据// 创建 JavaPairRDD// 自定义分区器，按照键进行分区// 对每个分区使用排序算子进行排序并获取 TopN 值// 指定要获取的 TopN 值的数量});// 打印结果sc.stop();// 自定义分区器@Overridereturn 3;// 指定分区数。
Spark--分组TopN
chbxw
05-30 2742
为了获取每个分组的topN， 首先要进行分组， 再对每个分组进行排序，获取TopN。测试数据hadoop 23 spark 45 java 90 spark 57 spark 90 hadoop 99 hadoop 76 spark 45 spark 88 spark 89 hadoop 45 hadoop 90 java 78 java 701.1、第一步， 将源数据转化为（key， value）
Spark-Core分组求TOPN的六种不同的实现方式
Fresh_man888的博客
12-02 595
案例:计算学科最受欢迎老师TopN 1.需求:根据网站的行为日志，统计每个学科最受欢迎老师的TopN，即按照学科分组，在每一个组内进行排序 2. 样例数据: http://bigdata.51doit.cn/laozhang http://bigdata.51doit.cn/laozhang http://bigdata.51doit.cn/laozhao http://bigdata.51doit.cn/laozhao http://bigdata.51doit.cn/laozhao h
Spark：求出分组内的TopN
weixin_33739523的博客
07-24 149
制作测试数据源： c1 85 c2 77 c3 88 c1 22 c1 66 c3 95 c3 54 c2 91 c2 66 c1 54 c1 65 c2 41 c4 65 spark scala实现代码： import org.apache.spark.SparkConf import org.apache.spark.sql.SparkSession...
Spark之两种方式分组取topN
yj2434的博客
10-29 484
原始数据： class1 90 class2 56 class1 87 class1 76 class2 88 class1 95 class1 74 class2 87 class2 67 class2 77 import org.apache.spark.{SparkConf, SparkContext} import org.apache.spark.rdd.RDD import scala.util.control.Breaks /** * 分组取topN问题，分好组之后，两种获取topN数
Spark中实现分组取TopN（scala版）
m0_61682601的博客
10-22 699
取出每班成绩的前三名
sparkrdd中分组取topn案例以及优化
最新发布
09-16
Spark RDD中分组取TopN案例是指在一个RDD中，根据某个键值进行分组，然后对每个组内的数据进行排序，取出每个组内的前N个数据。这种操作在数据分析和处理中非常常见，可以用于统计每个地区的销售额排名前N的产品、每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值