新增一个值，刷新全局数据的排序值简单方法

一批有sorted排序值的数据

id	sorted
centered 1	right-aligned 2
centered 2	right-aligned 3
centered 3	right-aligned 4
centered 4	right-aligned 7
centered 5	right-aligned 9

现在需要添加一条数据id=6的数据但是要排在第一位，设置sorted值为2，其他的sorted需要变化，怎么做到改变最少条数的sorted值，依然保持sorted有序呢？

package test;

import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author zloser
 * @update 2023/10/26 21:21
 * @since 2023/10/26 21:21
 **/
public class TestSorted {
    static class Data {
        private Integer id;
        private Integer sorted;


        public Data() {

        }

        public Data(Integer id, Integer sorted) {
            this.id = id;
            this.sorted = sorted;
        }

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public Integer getSorted() {
            return sorted;
        }

        public void setSorted(Integer sorted) {
            this.sorted = sorted;
        }
    }

    public static void main(String[] args) {
        List<Data> dataList = new ArrayList<>();
        dataList.add(new Data(1, 2));
        dataList.add(new Data(2, 3));
        dataList.add(new Data(3, 4));
        dataList.add(new Data(4, 7));
        dataList.add(new Data(5, 9));
        Data addData = new Data(6, 2);

        List<Data> updateList = refreshDataSorted(dataList, addData);
        System.out.println(updateList);
    }

    public static List<Data> refreshDataSorted(List<Data> dataList, Data addData) {

        dataList.add(addData);

        // 先过滤处大于等于新添加的sorted值的数据
        List<Data> geSortedData = dataList.stream().filter(it -> it.getSorted() >= addData.getSorted()).collect(Collectors.toList());

        // 小于sorted值的数据 ,这个不用动，最后整合就好了
        List<Data> ltSortedData = dataList.stream().filter(it -> it.getSorted() < addData.getSorted()).collect(Collectors.toList());

        // 先按sorted值分组
        Map<Integer, List<Data>> sortedGpMap = geSortedData.stream().collect(Collectors.groupingBy(Data::getSorted));

        // 对大于的排序值进行排序
        List<Integer> geSortedSortList = sortedGpMap.keySet().stream().sorted().collect(Collectors.toList());

        Map<Integer, Integer> addSortedNumMap = new HashMap<>();

        Integer lastMinSorted = addData.getSorted();
        // 计算哪些sorted值需要往后增加
        for (Integer sortedL : geSortedSortList) {
            if (sortedL <= lastMinSorted) {
                int num = lastMinSorted - sortedL + 1;
                // 记录需要变更的值，变更多少
                addSortedNumMap.put(sortedL, num);
                lastMinSorted += num;
            }else {
                ltSortedData.addAll(sortedGpMap.get(sortedL));
            }
        }
        // 修改值重新组装数据

        for (Integer sortedInt : addSortedNumMap.keySet()) {
            List<Data> orDefault = sortedGpMap.getOrDefault(sortedInt, null);
            if (CollectionUtils.isEmpty(orDefault)) {
                continue;
            }

            for (Data data : orDefault) {
                // 自身不修改
                if (!data.getId().equals(addData.getId())) {
                    data.setSorted(data.getSorted() + addSortedNumMap.get(sortedInt));
                }
                // 重新组装数据
                ltSortedData.add(data);
            }
        }
        return ltSortedData.stream().sorted(new Comparator<Data>() {
            @Override
            public int compare(Data o1, Data o2) {
                if (o1.getSorted() < o2.getSorted()) {
                    return -1;
                }
                return 0;
            }
        }).collect(Collectors.toList());

    }
}

代码献上，自己 GET，爱你的菜鸟程序员💋💋