List＜Map＜String,Object＞＞分页与多字段排序

List<Map<String,Object>>分页与多字段排序；粗暴一点直接上代码（注：仅提取核心代码）：
后一篇经验有更好的处理方法，这个方法基本上可以报废了：List＜Map＞用Comparator.comparing实现多字段排序
1.返回对象Report（要排序与分页的List<Map<String,Object>>对象设置进Body）

public class Report {
    /**
     * 内容
     */
    private List<Map<String, Object>> body = new ArrayList<>();
    /**
     * 当前页数
     */
    private int pageNum;
    /**
     * 分页大小
     */
    private int pageSize;
    /**
     * 总数
     */
    private long total;
    // setter/getter方法省略
}

2.分页与排序入参对象ReportParam；

public class ReportParam {
    private int pageSize;
    private int pageNum;
    private List<SortingField> sort;
    // getter、setter方法省略
}

3.排序对象；包含要排序的字段名称field与这个字段排序类型升序或降序；

public class SortingField {
	private String field;
    private String order;
    // getter、setter方法省略
}

对数据排序与分页；

/**
* <ul>
* <li>方法名: sortAndPage</li>
* <li>功能描述: 对数据排序与分页 </li>
* <li>创建人: eitan</li>
* <li>创建时间: 2024/1/4 11:18 </li>
* <li>修改备注: </li>
* </ul>
*
* @param report 
* @param sort
* @return void
*/
public void sortAndPage(Report report,ReportParam sort){
    // 对数据进行排序
    List<Map<String, Object>> body = sortToMap(report,sort.getSort());
    if (CollectionUtils.isNotEmpty(body)){
        // 对数据进行分页
        int pageNum = sort.getPageNum();
        int pageSize = sort.getPageSize();
        int startIndex = (pageNum - 1) * pageSize;
        int lastIndex = pageNum * pageSize;
        int count = body.size();
        if (lastIndex >= count) {
            lastIndex = count;
        }
        report.setPageNum(pageNum);
        report.setPageSize(pageSize);
        report.setTotal(count);
        report.setBody(body.subList(startIndex, lastIndex));
    }
}
  /**
  * <ul>
  * <li>方法名: sortToMap</li>
  * <li>功能描述: 对数据进行排序 </li>
  * <li>创建人: eitan</li>
  * <li>创建时间: 2024/1/3 17:11 </li>
  * <li>修改备注: </li>
  * </ul>
  *
  * @param report
  * @param sort
  * @return java.util.List<java.util.Map<java.lang.String,java.lang.Object>>
  */
private List<Map<String, Object>> sortToMap(Report report, List<SortingField> sort){
     List<Map<String, Object>> dataList = report.getBody();
     if (CollectionUtils.isNotEmpty(dataList)){
         if (CollectionUtils.isNotEmpty(sort) && StringUtils.hasText(sort.get(0).getField())){
             Collections.sort(dataList, new Comparator<Map<String, Object>>(){
                 public int compare(Map<String, Object> o1, Map<String, Object> o2){
                     int compareRes = 0;
                     for (SortingField sortingField : sort) {
                         compareRes = compareMulType(o1, o2, sortingField);
                         if (0 != compareRes){
                             return compareRes;
                         }
                     }
                     return compareRes;
                 }
             });
         }
         return dataList;
     }
     return new ArrayList<>();
 }
/**
  * <ul>
  * <li>方法名: compareMulType</li>
  * <li>功能描述: 返回两个对象比较结果（如果有其他类型数据可以进行扩展） </li>
  * <li>创建人: eitan</li>
  * <li>创建时间: 2024/1/4 13:32 </li>
  * <li>修改备注: </li>
  * </ul>
  *
  * @param o1
  * @param o2
  * @param sort
  * @return int
  */
private int compareMulType(Map<String, Object> o1, Map<String, Object> o2, SortingField sort) {
    if (o1.get(sort.getField()) instanceof String){
        String map1value = o1.get(sort.getField()).toString();
        String map2value = o2.get(sort.getField()).toString();
        if ("desc".equals(sort.getOrder())){
            return map2value.compareTo(map1value);
        }else{
            return map1value.compareTo(map2value);
        }
    }else{
        Double map1value = Double.parseDouble(o1.get(sort.getField()).toString());
        Double map2value = Double.parseDouble(o2.get(sort.getField()).toString());
        if (Objects.nonNull(map1value) && map1value.equals(map2value)){
            return 0;
        }
        if ("desc".equals(sort.getOrder())) {
            return map1value - map2value > 0 ? -1 : 1;
        } else {
            return map1value - map2value > 0 ? 1 : -1;
        }
    }
}