开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  Java怎么模拟rank/over函数实现获取分组排名

Java怎么模拟rank/over函数实现获取分组排名

其他教程   发布日期：2025年01月03日   浏览次数：199次

这篇“Java怎么模拟rank/over函数实现获取分组排名”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Java怎么模拟rank/over函数实现获取分组排名”文章吧。

背景

考试批次 班级 姓名 语文
202302 三年一班 张小明 130.00
202302 三年一班 王二小 128.00
202302 三年一班 谢春花 136.00
202302 三年二班 冯世杰 129.00
202302 三年二班 马功成 130.00
202302 三年二班 魏翩翩 136.00

假设我们有如上数据，现在有一个需求需要统计各学生语文单科成绩在班级中的排名和全年段排名，你会如何实现？

很容易的我们想到了 rank() over() 实现

over()是分析函数，可以和 rank()、 dense_rank() 、 row_number() 配合使用。

使用语法如下：

  1. RANK() OVER(PARTITION BY COLUMN ORDER BY COLUMN)
  2. dense_rank() OVER(PARTITION BY COLUMN ORDER BY COLUMN)
  3. ROW_NUMBER() OVER(PARTITION BY COLUMN ORDER BY COLUMN)

解释：partition by用于给结果集分组，如果没有指定那么它把整个结果集作为一个分组。

  • rank()涵数主要用于排序，并给出序号 ，对于排序并列的数据给予相同序号，并空出并列所占的名次。

  • dense_rank() 功能同rank()一样，区别在于不空出并列所占的名次

  • row_number()涵数则是按照顺序依次使用 ，不考虑并列

rank 结果为 1,2,2,4 dense_rank 结果为 1,2,2,3 row_number 结果为 1,2,3,4

实际应用中，会存在数据从其他外部系统接入且数据量不大等多种情况，那么使用Java代码的方式实现分组排名的功能则显得更加方便。

详细设计及实现

排序定义类 OrderBy

  1. public class OrderBy {
  2.     private String orderByEL;
  3.     /**
  4.      * 是否升序
  5.      */
  6.     private boolean ascend;
  8.     public OrderBy(){
  9.         //默认升序
  10.         this.ascend = true;
  11.     }
  13.     public String orderByEL(){
  14.         return this.orderByEL;
  15.     }
  17.     public OrderBy orderByEL(String orderByEL){
  18.         this.orderByEL = orderByEL;
  19.         return this;
  20.     }
  22.     public OrderBy ascend(boolean ascend){
  23.         this.ascend = ascend;
  24.         return this;
  25.     }
  27.     public boolean ascend(){
  28.         return this.ascend;
  29.     }
  30. }

该类定义了如下属性：

  • 排序的fileld

  • 是否升序

获取排名方法

该方法定义如下：

  1. <T> void rankOver(List<T> dataList, String[] partitionByFields, List<OrderBy> orderByList, String resultField, int rankType);

该方法提供了5个入参：

dataList 排序的数据集

partitionByFields 分组field的数组

orderByList 排序字段集合

resultField 排名结果存放的字段

rankType 排名方式

  • 1:不考虑并列（row_number 结果为 1,2,3,4）

  • 2:考虑并列，空出并列所占的名次（rank 结果为 1,2,2,4）

  • 3:考虑并列，不空出并列所占的名次（dense_rank 1,2,2,3）

该方法具体实现如下

  1.     public static <T> void rankOver(List<T> dataList, String[] partitionByFields, List<OrderBy> orderByList, String resultField, int rankType) {
  2.         if (CollectionUtils.isEmpty(orderByList)) {
  3.             return;
  4.         }
  5.         //STEP_01 剔除掉不参与排名的数据
  6.         List<T> tempList = new ArrayList<>();
  7.         for (T data : dataList) {
  8.             boolean part = true;
  9.             for (OrderBy rptOrderBy : orderByList) {
  10.                 Object o1 = executeSpEL(rptOrderBy.orderByEL(), data);
  11.                 if (o1 == null) {
  12.                     //参与排序的值为null的话则不参与排名
  13.                     part = false;
  14.                     break;
  15.                 }
  16.             }
  17.             if (part) {
  18.                 tempList.add(data);
  19.             }
  20.         }
  21.         if (CollectionUtils.isEmpty(tempList)) {
  22.             return;
  23.         }
  24.         //STEP_02 分组
  25.         Map<String, List<T>> groupMap = group(tempList, null, partitionByFields);
  26.         for (List<T> groupDataList : groupMap.values()) {
  27.             order(orderByList, groupDataList);
  28.             if (rankType == 1) {
  29.                 int rank = 1;
  30.                 for (T temp : groupDataList) {
  31.                     setFieldValue(temp, resultField, rank);
  32.                     rank++;
  33.                 }
  34.             } else {
  35.                 int prevRank = Integer.MIN_VALUE;
  36.                 int size = groupDataList.size();
  37.                 for (int i = 0; i < size; i++) {
  38.                     T current = groupDataList.get(i);
  39.                     if (i == 0) {
  40.                         //第一名
  41.                         setFieldValue(current, resultField, 1);
  42.                         prevRank = 1;
  43.                     } else {
  44.                         T prev = groupDataList.get(i - 1);
  45.                         boolean sameRankWithPrev = true;//并列排名
  46.                         for (OrderBy rptOrderBy : orderByList) {
  47.                             Object o1 = executeSpEL(rptOrderBy.orderByEL(), current);
  48.                             Object o2 = executeSpEL(rptOrderBy.orderByEL(), prev);
  49.                             if (!o1.equals(o2)) {
  50.                                 sameRankWithPrev = false;
  51.                                 break;
  52.                             }
  53.                         }
  54.                         if (sameRankWithPrev) {
  55.                             setFieldValue(current, resultField, getFieldValue(prev, resultField));
  56.                             if (rankType == 2) {
  57.                                 ++prevRank;
  58.                             }
  59.                         } else {
  60.                             setFieldValue(current, resultField, ++prevRank);
  61.                         }
  62.                     }
  63.                 }
  64.             }
  65.         }
  66.     }

使用案例

定义一个学生类：

  1. public class Student {
  2.     private String batch;
  3.     private String banji;
  4.     private String name;
  5.     private Double yuwen;
  6.     //extra
  7.     private Integer rank1;
  8.     private Integer rank2;
  9.     
  10.     public Student(String batch, String banji, String name, Double yuwen) {
  11.         this.batch = batch;
  12.         this.banji = banji;
  13.         this.name = name;
  14.         this.yuwen = yuwen;
  15.     }
  16. }

我们写一个方法，返回如下数据：

  1. public List<Student> getDataList() {
  2.     List<Student> dataList = new ArrayList<>();
  3.     dataList.add(new Student("202302", "三年一班", "张小明", 130.0));
  4.     dataList.add(new Student("202302", "三年一班", "王二小", 128.0));
  5.     dataList.add(new Student("202302", "三年一班", "谢春花", 136.0));
  6.     dataList.add(new Student("202302", "三年二班", "冯世杰", 129.0));
  7.     dataList.add(new Student("202302", "三年二班", "马功成", 130.0));
  8.     dataList.add(new Student("202302", "三年二班", "魏翩翩", 136.0));
  9.     return dataList;
  10. }

获取学生语文成绩的班级排名和年段排名，排名采用并列并空出并列所占用名次的方式。

  1. List<Student> dataList = getDataList();
  2. List<OrderBy> orderByList = new ArrayList<>();
  3. orderByList.add(new OrderBy().orderByEL("yuwen").ascend(false));
  4. //获取全校排名
  5. DataProcessUtil.rankOver(dataList, new String[]{"batch"}, orderByList, "rank1", 2);
  6. //获取班级排名
  7. DataProcessUtil.rankOver(dataList, new String[]{"batch", "banji"}, orderByList, "rank2", 2);
  8. log("语文单科成绩排名情况如下：");
  10. Map<String, List<Student>> groupMap = DataProcessUtil.group(dataList, null, new String[]{"batch"});
  11. for (Map.Entry<String, List<Student>> entry : groupMap.entrySet()) {
  12.     log("考试批次：" + entry.getKey());
  13.     for (Student s : entry.getValue()) {
  14.         log(String.format("班级：%s 学生：%s 语文成绩：%s 班级排名：%s 全校排名：%s", s.getBanji(), s.getName(), s.getYuwen(), s.getRank2(), s.getRank1()));
  15.     }
  16.     log("");
  17. }

结果如下：

语文单科成绩排名情况如下：
考试批次：202302
班级：三年一班 学生：张小明 语文成绩：130.0 班级排名：2 全校排名：3
班级：三年一班 学生：王二小 语文成绩：128.0 班级排名：3 全校排名：6
班级：三年一班 学生：谢春花 语文成绩：136.0 班级排名：1 全校排名：1
班级：三年二班 学生：冯世杰 语文成绩：129.0 班级排名：3 全校排名：5
班级：三年二班 学生：马功成 语文成绩：130.0 班级排名：2 全校排名：3
班级：三年二班 学生：魏翩翩 语文成绩：136.0 班级排名：1 全校排名：1

可以看到全校排名中 有两个并列第一名 两个并列第三名，且空出了并列所占用的名次2 和 名次4

以上就是Java怎么模拟rank/over函数实现获取分组排名的详细内容，更多关于Java怎么模拟rank/over函数实现获取分组排名的资料请关注九品源码其它相关文章！

相关热词： Java模拟rankover函数实现获取分组排名
上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
下一篇：SpringBoot怎么使用Sa-Token实现权限认证

文章分类

IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

最后更新

热门排行

网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1