根据指标体系树重排序算法

指标体系数
例子：
2
2.3
2.3.1
2.3.4
2.4
2.4.3
2.4.5

1.对序号进行些排序并重写

public static void changeOrderValueWithNaturalNumber(List<ExportAnnualDataDto> resultList) {
        if (org.apache.commons.collections4.CollectionUtils.isEmpty(resultList)){
            return;
        }
        // 序号按点分割，取最大的长度，同时将分隔好的字符串数组放入对应的dto中，避免后续使用的时候浪费资源
        Integer max = resultList.stream()
                .peek(e->e.setOrderArr(org.apache.commons.lang3.StringUtils.split(e.getOrder(), ".")))
                .map(e -> e.getOrderArr().length).max(Comparator.comparingInt(e -> e)).get();

        // 根据序号的第一个值分组然后排序
        Map<Integer, List<ExportAnnualDataDto>> collect = resultList.stream()
                .collect(Collectors.groupingBy(e -> Integer.valueOf(e.getOrderArr()[0]), TreeMap::new,Collectors.toList()));
        // 第一位的数据
        int firstNum=1;
        // 遍历分组集合
        for (Map.Entry<Integer, List<ExportAnnualDataDto>> entry : collect.entrySet()) {
            // 每一组的数据
            List<ExportAnnualDataDto> value = entry.getValue();
            // 按位的自然数顺序排序
            sort(max,value);
            // 获取最大数组的长度
            Integer maxLength = value.stream().map(e -> e.getOrderArr().length).max(Comparator.comparingInt(e -> e)).get();
            // 创建int数组，对应每一位序号的值
            int[] formatArr = new int[maxLength];
            // 固定第一位序号的值
            formatArr[0] = firstNum;
            // 记录上一次的长度
            int lastLength =-1;
            // 遍历每一组的数据
            for (int i = 0; i < value.size(); i++) {
                ExportAnnualDataDto dataDto = value.get(i);
                // 获取当前数据的顺序位数
                int length = dataDto.getOrderArr().length;
                // 非第一次
                if (i!=0){
                    // 当前长度小于上一次的长度
                    if (lastLength>length) {
                        // 将当前长度之后的位所在数据清零，重新计算
                        for (int j =length; j < maxLength; j++) {
                            formatArr[j]=0;
                        }
                    }
                }
                if (length!=1){
                    // 如果不是第一位，则在当前位数上加1
                    formatArr[length-1]=(formatArr[length-1])+1;
                }
                // 根据位数拼接新的序号
                StringJoiner joiner = new StringJoiner(".");
                for (int j = 0; j < length; j++) {
                    joiner.add(String.valueOf(formatArr[j]));
                }
                // 将新的序号更新回实体中
                dataDto.setOrder(joiner.toString());
                // 将当前长度设置为上一次长度，用于下一次循环比较
                lastLength = length;
            }
            // 第一位数据的值加1
            firstNum++;
        }
        // 整体返回的值进行排序
        sort(max, resultList);
        // 移除Order数组
        resultList.forEach(e->e.setOrderArr(null));
    }

    private static void sort(Integer max, List<ExportAnnualDataDto> list) {
        Comparator<ExportAnnualDataDto> comparing = Comparator.comparing(o -> Integer.valueOf(o.getOrderArr()[0]));
        for (int i = 1; i < max; i++) {
            final int index = i;
            comparing = comparing.thenComparing(Comparator.nullsFirst(Comparator.comparing(o -> {
                if (o.getOrderArr().length > index) {
                    return Integer.valueOf(o.getOrderArr()[index]);
                } else {
                    return 0;
                }
            })));
        }
        list.sort(comparing);
    }

2.仅对序号进行排序

public static void onlyByOrder(List<ExportAnnualDataDto> resultList) {
        if (org.apache.commons.collections4.CollectionUtils.isEmpty(resultList)) {
            return;
        }
        // 序号按点分割，取最大的长度，同时将分隔好的字符串数组放入对应的dto中，避免后续使用的时候浪费资源
        Integer max = resultList.stream()
                .peek(e -> e.setOrderArr(org.apache.commons.lang3.StringUtils.split(e.getOrder(), ".")))
                .map(e -> e.getOrderArr().length).max(Comparator.comparingInt(e -> e)).get();

        // 根据序号的第一个值分组然后排序
        Map<Integer, List<ExportAnnualDataDto>> collect = resultList.stream()
                .collect(Collectors.groupingBy(e -> Integer.valueOf(e.getOrderArr()[0]), TreeMap::new, Collectors.toList()));
        // 第一位的数据
        // 遍历分组集合
        for (Map.Entry<Integer, List<ExportAnnualDataDto>> entry : collect.entrySet()) {
            // 每一组的数据
            List<ExportAnnualDataDto> value = entry.getValue();
            // 按位的自然数顺序排序
            sort(max, value);
        }
        // 整体返回的值进行排序
        sort(max, resultList);
        // 移除Order数组
        resultList.forEach(e -> e.setOrderArr(null));
    }


    private static void sort(Integer max, List<ExportAnnualDataDto> list) {
        Comparator<ExportAnnualDataDto> comparing = Comparator.comparing(o -> Integer.valueOf(o.getOrderArr()[0]));
        for (int i = 1; i < max; i++) {
            final int index = i;
            comparing = comparing.thenComparing(Comparator.nullsFirst(Comparator.comparing(o -> {
                if (o.getOrderArr().length > index) {
                    return Integer.valueOf(o.getOrderArr()[index]);
                } else {
                    return 0;
                }
            })));
        }
        list.sort(comparing);
    }