Comment simuler la fonction Rank/Over en Java pour obtenir un classement de groupe

Contexte

Lot d'examen	Classe	Nom	Chinois
202302	Classe trois ans	Zhang Xiaoming	130.00
202302	Classe trois tous les trois ans	Wang Deuxième école primaire	128.00
202302	Classe trois pour trois ans	Xie Chunhua	136.00
202302	Classe deux pour trois ans	F fra Shijie	129.00
202302	Trois ans et deux Classe	Ma Gongcheng	130.00
202302	Classe 2 de la troisième année	Wei Pianpian	136.00

Supposons que nous disposions des données ci-dessus et qu'il existe désormais un besoin de compter la langue chinoise de chaque élève Résultats d'une seule matière en classe Comment parviendrez-vous à atteindre le classement dans le classement et le classement dans le segment de l'année complète ?

Il est facile pour nous de penser à l'implémentation de Rank() over()

over() est une fonction analytique qui peut être utilisée conjointement avec Rank(), dense_rank() et row_number().

La syntaxe d'utilisation est la suivante :

RANK() OVER(PARTITION BY COLUMN ORDER BY COLUMN)
dense_rank() OVER(PARTITION BY COLUMN ORDER BY COLUMN)
ROW_NUMBER() OVER(PARTITION BY COLUMN ORDER BY COLUMN)

Explication : partition by est utilisée pour regrouper l'ensemble de résultats Si elle n'est pas spécifiée, elle traite l'ensemble de résultats comme un groupe. La fonction

• rank() est principalement utilisée pour le tri, et donne un numéro de séquence. Le même numéro de séquence est donné aux données triées et parallèles, et le classement de l'égalité est effacé.

• dense_rank() a la même fonction que Rank(), la différence est que le classement occupé par l'égalité n'est pas effacé

• La fonctionrow_number() est utilisée dans l'ordre, sans tenir compte de l'égalité

rank result Le résultat est 1,2,2,4 dense_rank et le résultat est 1,2,2,3 row_number et le résultat est 1,2,3,4

Dans les applications réelles, les données seront accessibles depuis d'autres systèmes externes et la quantité de données n'est pas importante. Dans de nombreux cas, il est plus pratique d'utiliser du code Java pour implémenter la fonction de classement de groupe.

Conception détaillée et implémentation

Classe de définition d'ordre OrderBy

public class OrderBy {
    private String orderByEL;
    /**
     * 是否升序
     */
    private boolean ascend;

    public OrderBy(){
        //默认升序
        this.ascend = true;
    }

    public String orderByEL(){
        return this.orderByEL;
    }

    public OrderBy orderByEL(String orderByEL){
        this.orderByEL = orderByEL;
        return this;
    }

    public OrderBy ascend(boolean ascend){
        this.ascend = ascend;
        return this;
    }

    public boolean ascend(){
        return this.ascend;
    }
}

Cette classe définit les attributs suivants :

• Le fichier trié

• Qu'il soit par ordre croissant

Obtenir la méthode de classement

Le La méthode est définie comme suit :

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

Cette méthode fournit 5 paramètres d'entrée :

ensemble de données triées dataList

tableau partitionByFields de champs groupés

collection de champs de tri orderByList

champ resultField où les résultats du classement sont stockés

méthode de classementrankType

• 1 : Ne pas considérer les égalités (le résultat row_number est 1,2,3,4)

• 2 : Considérer l'égalité et laisser le classement occupé par l'égalité (le résultat du classement est 1,2,2, 4)

• 3 : Considérez-le à égalité, ne laissez pas de côté les rangs à égalité (dense_rank 1,2,2,3)

La mise en œuvre spécifique de cette méthode est la suivante

    public static <T> void rankOver(List<T> dataList, String[] partitionByFields, List<OrderBy> orderByList, String resultField, int rankType) {
        if (CollectionUtils.isEmpty(orderByList)) {
            return;
        }
        //STEP_01 剔除掉不参与排名的数据
        List<T> tempList = new ArrayList<>();
        for (T data : dataList) {
            boolean part = true;
            for (OrderBy rptOrderBy : orderByList) {
                Object o1 = executeSpEL(rptOrderBy.orderByEL(), data);
                if (o1 == null) {
                    //参与排序的值为null的话则不参与排名
                    part = false;
                    break;
                }
            }
            if (part) {
                tempList.add(data);
            }
        }
        if (CollectionUtils.isEmpty(tempList)) {
            return;
        }
        //STEP_02 分组
        Map<String, List<T>> groupMap = group(tempList, null, partitionByFields);
        for (List<T> groupDataList : groupMap.values()) {
            order(orderByList, groupDataList);
            if (rankType == 1) {
                int rank = 1;
                for (T temp : groupDataList) {
                    setFieldValue(temp, resultField, rank);
                    rank++;
                }
            } else {
                int prevRank = Integer.MIN_VALUE;
                int size = groupDataList.size();
                for (int i = 0; i < size; i++) {
                    T current = groupDataList.get(i);
                    if (i == 0) {
                        //第一名
                        setFieldValue(current, resultField, 1);
                        prevRank = 1;
                    } else {
                        T prev = groupDataList.get(i - 1);
                        boolean sameRankWithPrev = true;//并列排名
                        for (OrderBy rptOrderBy : orderByList) {
                            Object o1 = executeSpEL(rptOrderBy.orderByEL(), current);
                            Object o2 = executeSpEL(rptOrderBy.orderByEL(), prev);
                            if (!o1.equals(o2)) {
                                sameRankWithPrev = false;
                                break;
                            }
                        }
                        if (sameRankWithPrev) {
                            setFieldValue(current, resultField, getFieldValue(prev, resultField));
                            if (rankType == 2) {
                                ++prevRank;
                            }
                        } else {
                            setFieldValue(current, resultField, ++prevRank);
                        }
                    }
                }
            }
        }
    }

Cas d'utilisation

Définir une classe d'étudiant :

public class Student {
    private String batch;
    private String banji;
    private String name;
    private Double yuwen;
    //extra
    private Integer rank1;
    private Integer rank2;
    
    public Student(String batch, String banji, String name, Double yuwen) {
        this.batch = batch;
        this.banji = banji;
        this.name = name;
        this.yuwen = yuwen;
    }
}

Nous écrivons une méthode qui renvoie les données suivantes :

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

Obtenez le classement de classe et le classement annuel des résultats en langue chinoise des étudiants. Le classement est basé sur la méthode d'égalité et d'exclusion des positions liées.

List<Student> dataList = getDataList();
List<OrderBy> orderByList = new ArrayList<>();
orderByList.add(new OrderBy().orderByEL("yuwen").ascend(false));
//获取全校排名
DataProcessUtil.rankOver(dataList, new String[]{"batch"}, orderByList, "rank1", 2);
//获取班级排名
DataProcessUtil.rankOver(dataList, new String[]{"batch", "banji"}, orderByList, "rank2", 2);
log("语文单科成绩排名情况如下：");

Map<String, List<Student>> groupMap = DataProcessUtil.group(dataList, null, new String[]{"batch"});
for (Map.Entry<String, List<Student>> entry : groupMap.entrySet()) {
    log("考试批次：" + entry.getKey());
    for (Student s : entry.getValue()) {
        log(String.format("班级：%s 学生：%s 语文成绩：%s 班级排名：%s 全校排名：%s", s.getBanji(), s.getName(), s.getYuwen(), s.getRank2(), s.getRank1()));
    }
    log("");
}

Les résultats sont les suivants :

Le classement des scores des matières chinoises est le suivant :
Lot d'examens : 202302
Classe : Classe 1, 3e année Élève : Zhang Xiaoming Score chinois : 130,0 Classement de la classe : 2 Classement de l'ensemble de l'école : 3
Classe : Élève de 3e année de classe 1 : Wang Er Xiao Score en chinois : 128,0 Classement de la classe : 3 Classement de l'ensemble de l'école : 6
Classe : Élève de classe 3 : Feng Shijie Score de langue chinoise : 129,0 Classement de la classe : 3 Classement de l'ensemble de l'école : 5
Classe : Élève de 2e année de 3e année : Ma Gongcheng Note chinoise : 130,0 Classement de la classe : 2 Classement de l'ensemble de l'école : 3
Classe : Élève de 2e année de 3e année : Wei Pianpian Note chinoise : 136,0 Classement de la classe : 1 Classement de l'école : 1

Vous pouvez voir que dans le classement des écoles, il y en a deux à égalité pour la première place et deux à égalité pour la troisième place, et les positions 2 et 4 à égalité sont vacantes

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!