基于未知字段列表动态排序HashMap<String, Object>列表

核心思路 #

动态构建Comparator的关键在于：先基于第一个排序字段初始化基础比较器，然后遍历剩余的排序字段，依次调用thenComparing()方法链式拼接，最终得到符合复合排序规则的Comparator。同时需要处理不同数据类型的比较逻辑，确保扩展性。

类型适配与比较器工具 #

先实现一个工具方法，根据字段值的实际类型生成对应的比较器，支持升序/降序（默认升序）：

import java.time.LocalDateTime;
import java.util.Comparator;
import java.util.HashMap;

public class DynamicSortUtil {

    // 根据字段名和排序方向获取对应比较器
    private static Comparator<HashMap<String, Object>> getFieldComparator(String field, boolean isAscending) {
        Comparator<HashMap<String, Object>> comparator = (map1, map2) -> {
            Object val1 = map1.get(field);
            Object val2 = map2.get(field);

            // 处理null值，默认null排在前面
            if (val1 == null && val2 == null) return 0;
            if (val1 == null) return -1;
            if (val2 == null) return 1;

            // 根据实际类型执行比较
            if (val1 instanceof Long && val2 instanceof Long) {
                return ((Long) val1).compareTo((Long) val2);
            } else if (val1 instanceof Double && val2 instanceof Double) {
                return ((Double) val1).compareTo((Double) val2);
            } else if (val1 instanceof String && val2 instanceof String) {
                return ((String) val1).compareTo((String) val2);
            } else if (val1 instanceof LocalDateTime && val2 instanceof LocalDateTime) {
                return ((LocalDateTime) val1).compareTo((LocalDateTime) val2);
            } else {
                // 其他类型默认调用toString比较，可按需扩展
                return val1.toString().compareTo(val2.toString());
            }
        };
        return isAscending ? comparator : comparator.reversed();
    }
}

动态构建复合Comparator #

实现动态构建比较器的方法，接收排序字段列表（可附带方向，比如"id:desc"，默认升序）：

// 动态构建复合比较器，支持格式如 ["id", "speed:desc", "time"]
    public static Comparator<HashMap<String, Object>> buildDynamicComparator(String... sortFields) {
        if (sortFields == null || sortFields.length == 0) {
            throw new IllegalArgumentException("排序字段列表不能为空");
        }

        // 初始化第一个字段的比较器
        String firstField = sortFields[0];
        boolean firstAsc = !firstField.contains(":desc");
        String firstFieldName = firstField.split(":")[0];
        Comparator<HashMap<String, Object>> comparator = getFieldComparator(firstFieldName, firstAsc);

        // 遍历剩余字段，链式拼接thenComparing
        for (int i = 1; i < sortFields.length; i++) {
            String field = sortFields[i];
            boolean isAsc = !field.contains(":desc");
            String fieldName = field.split(":")[0];
            comparator = comparator.thenComparing(getFieldComparator(fieldName, isAsc));
        }

        return comparator;
    }

使用示例 #

直接调用工具方法对列表排序：

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<HashMap<String, Object>> dataList = new ArrayList<>();
        // 填充数据...

        // 示例1：按id、speed降序、time排序
        Comparator<HashMap<String, Object>> comparator1 = DynamicSortUtil.buildDynamicComparator("id", "speed:desc", "time");
        dataList.sort(comparator1);

        // 示例2：仅按id升序排序
        Comparator<HashMap<String, Object>> comparator2 = DynamicSortUtil.buildDynamicComparator("id");
        dataList.sort(comparator2);
    }
}

扩展性说明 #

• 若需要支持新的数据类型，只需在getFieldComparator方法中添加对应的类型判断分支即可。
• 可以扩展排序方向的解析逻辑，比如支持:asc显式声明升序，或自定义其他规则。

内容的提问来源于stack exchange，提问作者Frank