多字段排序工具类，支持树形

多字段排序工具类，用于对包含多个字段的列表进行自定义排序，默认字段S_SORT_NO
支持树形，树形格式为1.1 1.1.1 1.1.2格式

public class MultiFieldSorter {

    /**
     * @param dataList  数据列表
     * @param sortRules 排序规则
     * @param treeTable 树形标记
     * @Description 根据提供的排序规则对数据列表进行多字段排序。
     * @author Andawell信息技术
     * @date 2025-05-26
     */
    public static void sort(List<Map<String, Object>> dataList, List<Map<String, String>> sortRules, boolean treeTable) {
        if (dataList == null) {
            return;
        }
        Comparator<Map<String, Object>> comparator;
        if (sortRules == null || sortRules.isEmpty()) {
            // 默认排序 树形子表 s_sort_no 的值有点 如1.1.1 1.1.2 1.2.1 1.2.2 以此类推 非树形子表直接按照s_sort_no排序
            comparator = createComparator(treeTable);
        } else {

            // 使用Comparator链式调用构建多字段排序
            comparator = sortRules.stream()
                    .map(rule -> createComparator(rule.get(SipdmConstant.FIELD), rule.get("sort")))
                    .reduce(Comparator::thenComparing)
                    .orElse((o1, o2) -> 0);
        }

        // 执行排序
        dataList.sort(comparator);
    }

    /**
     * @param treeTable 树表
     * @return {@link Comparator }<{@link Map }<{@link String }, {@link Object }>>
     * @Description 默认排序比较器
     * @author Andawell信息技术
     * @date 2025-05-27
     */
    private static Comparator<Map<String, Object>> createComparator(boolean treeTable) {
        return new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> m1, Map<String, Object> m2) {
                Object v1 = m1.get(TableFeildsEnum.S_SORT_NO.getField().toUpperCase());
                Object v2 = m2.get(TableFeildsEnum.S_SORT_NO.getField().toUpperCase());
                if (v1 == null || v2 == null) {
                    return 0;
                }
                // 根据是否树形表选择不同的比较策略
                if (treeTable) {
                    return compareHierarchical(v1.toString(), v2.toString());
                } else {
                    return compareNumeric(v1.toString(), v2.toString());
                }
            }

            /**
             * @param s1 字符串1
             * @param s2 字符串2
             * @return int 返回值
             * @Description 树形层级编号比较
             * @author Andawell信息技术
             * @date 2025-05-27
             */
            private int compareHierarchical(String s1, String s2) {
                String[] parts1 = s1.split("\\.");
                String[] parts2 = s2.split("\\.");

                int maxLength = Math.max(parts1.length, parts2.length);
                for (int i = 0; i < maxLength; i++) {
                    int num1 = i < parts1.length ? Integer.parseInt(parts1[i]) : 0;
                    int num2 = i < parts2.length ? Integer.parseInt(parts2[i]) : 0;

                    int result = Integer.compare(num1, num2);
                    if (result != 0) {
                        return result;
                    }
                }
                return 0;
            }

            /**
             * @param s1 字符串1
             * @param s2 字符串2
             * @return int 返回值
             * @Description 非树形数值比较
             * @author Andawell信息技术
             * @date 2025-05-27
             */
            private int compareNumeric(String s1, String s2) {
                try {
                    double num1 = Double.parseDouble(s1);
                    double num2 = Double.parseDouble(s2);
                    return Double.compare(num1, num2);
                } catch (NumberFormatException e) {
                    // 如果无法转换为数字，退回到字符串比较
                    return s1.compareTo(s2);
                }
            }
        };
    }

    /**
     * @param field 字段
     * @param sort  排序
     * @return {@link Comparator }<{@link Map }<{@link String }, {@link Object }>>
     * @Description 根据规则创建比较器
     * @author Andawell信息技术
     * @date 2025-05-27
     */
    private static Comparator<Map<String, Object>> createComparator(String field, String sort) {
        return (o1, o2) -> {
            Object value1 = o1.get(field);
            Object value2 = o2.get(field);

            // 处理null值
            if (value1 == null && value2 == null) {
                return 0;
            }
            if (value1 == null) {
                return "asc".equalsIgnoreCase(sort) ? -1 : 1;
            }
            if (value2 == null) {
                return "asc".equalsIgnoreCase(sort) ? 1 : -1;
            }

            // 处理Comparable类型
            if (value1 instanceof Comparable && value2 instanceof Comparable) {
                @SuppressWarnings("unchecked")
                int result = ((Comparable<Object>) value1).compareTo(value2);
                return "desc".equalsIgnoreCase(sort) ? -result : result;
            }

            // 非Comparable类型转为String比较
            int result = value1.toString().compareTo(value2.toString());
            return "desc".equalsIgnoreCase(sort) ? -result : result;
        };
    }
}