List＜Map＜String,Object＞＞实现多字段排序

继上次实现Comparetor接口重写compare方法后，发现诸多不便，这次直接使用了Comparator实现了多字段排序（目前是三个，可以自己拓展），目前把核心代码贴在这里，方便记录，也很简单，读一下就大致知道了；

private static Collator collator = Collator.getInstance(Locale.CHINA);

/**
     * <ul>
     * <li>方法名: sortToMap</li>
     * <li>功能描述: 对数据进行排序 </li>
     * <li>创建人: yt </li>
     * <li>创建时间: 2024/1/3 17:11 </li>
     * <li>修改备注: 排序的列表字段包含一种情况：某个字段会存在两种类型的数据 数值型&'-'字符，
     * 				排序兼容：
     *              比较时将'-'字符覆盖为-9999999.9；
     *              指定需要转换数值的列名（比较时会校验），其余列不需要转换直接参与比较
     * </li>
     * </ul>
     *
     * @param report
     * @param sortingFieldList
     * @param needTransformNumFieldNames 需要转换数值的列名
     * @return java.util.List<java.util.Map < java.lang.String, java.lang.Object>>
     */
public List<Map<String, Object>> sortToMap(Report report, List<SortingField> sortingFieldList, List<String> needTransformNumFieldNames){
        List<Map<String, Object>> dataList = report.getBody();
        if (CollectionUtils.isNotEmpty(dataList)){
            if (CollectionUtils.isNotEmpty(sortingFieldList) && StringUtils.hasText(sortingFieldList.get(0).getField())){
                List<Comparator<Map<String, Object>>> comparatorList = new ArrayList<>(sortingFieldList.size());
                // 构建比较器
                for (SortingField sortingField : sortingFieldList) {
                    Comparator<Map<String, Object>> sort;
                    // 比较列是需要转换为数值型的
                    if (CollectionUtils.isNotEmpty(needTransformNumFieldNames) && needTransformNumFieldNames.contains(sortingField.getField())){
                        if ("desc".equals(sortingField.getOrder())){
                            sort = Comparator.comparing((Map<String, Object> map) ->
                                        Double.parseDouble(
                                                // 不为空的情况下，不为'-'字符 原样转换 ，'-'字符 覆盖为-9999999.8 ，否则为null覆盖为-9999999.9
                                                Objects.nonNull(map.get(sortingField.getField()))?
                                                        !"-".equals(map.get(sortingField.getField()).toString())?map.get(sortingField.getField()).toString():"-9999999.8":"-9999999.9")
                                                ,Comparator.nullsLast(Double::compareTo).reversed());
                        }else{
                            sort = Comparator.comparing((Map<String, Object> map) ->
                                        Double.parseDouble(
                                                // 不为空的情况下，不为'-'字符 原样转换 ，'-'字符 覆盖为-9999999.8 ，否则为null覆盖为-9999999.9
                                                Objects.nonNull(map.get(sortingField.getField()))?
                                                        !"-".equals(map.get(sortingField.getField()).toString())?map.get(sortingField.getField()).toString():"-9999999.8":"-9999999.9")
                                                ,Comparator.nullsLast(Double::compareTo));
                        }
                    }else{
                        // 比较列不需要转换 collator这个是中文比较器 会根据拼音首字母排序
                        if ("desc".equals(sortingField.getOrder())){
                            sort = Comparator.comparing((Map<String, Object> map) ->
                                            Objects.nonNull(map.get(sortingField.getField()))?map.get(sortingField.getField()).toString():""
                                    ,Comparator.nullsLast(collator::compare).reversed());
                        }else{
                            sort = Comparator.comparing((Map<String, Object> map) ->
                                            Objects.nonNull(map.get(sortingField.getField()))?map.get(sortingField.getField()).toString():""
                                    ,Comparator.nullsFirst(collator::compare));
                        }
                    }
                    comparatorList.add(sort);
                }
                if (comparatorList.size()==1){
                    dataList.sort(comparatorList.get(0));
                } else if (comparatorList.size()==2){
                    dataList.sort(comparatorList.get(0).thenComparing(comparatorList.get(1)));
                } else {
                    dataList.sort(comparatorList.get(0).thenComparing(comparatorList.get(1)).thenComparing(comparatorList.get(2)));
                }
            }
            return dataList;
        }
        return new ArrayList<>();
    }