数据修改排序

import org.apache.commons.lang3.ObjectUtils;

import java.lang.reflect.Field;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * 修改 例：A(1) B(2) C(3) D(4) 要先把C改2，
 *      A(1) B(2) D(3)
 *      A(1) C(2) B(3)  D(4)
 * 删除 需自己实现
 * @param <T>
 */
public class UpdateSortPro<T> {

    /**
     * @param newObj                 手动修改的数据 newData
     * @param queryGroupListSupplier 查询与手动修改数组同一组的所有数据
     * @param idFunction             获取主键
     * @param updateConsumer         更新受影响的数据
     */
    public void updateSort(T newObj,
                           Supplier<List<T>> queryGroupListSupplier,
                           Function<T, Long> idFunction,
                           Consumer<List<T>> updateConsumer) {
        //对原对象进行封装，方便后面操作
        List<T> allDataInGroup = queryGroupListSupplier.get();
        List<SortBeanWrapper> oneGroup = wrap(allDataInGroup);
        SortBeanWrapper newSortBean = wrap(newObj);
        //弹出需要主动修改的那条数据
        SortBeanWrapper oldObj = takeOldObj(newObj, idFunction, oneGroup);

        int newSort = newSortBean.getSort();
        int oldSort = oldObj.getSort();

        if (newSort == oldSort) { //若没有更新排序，则只更新当前数据
            updateConsumer.accept(Collections.singletonList(newObj));
            return;
        }
        //将数据重新排序
        initSort(oneGroup);
        //从newSort那里开始，所有的排序+1
        oneGroup.stream()
                .filter(item -> item.getSort() >= newSort)
                .forEach(item -> item.setSort(item.getSort() + 1));


        //筛选出Sort被修改的数据
        List<T> toSaveList = oneGroup.stream()
                .filter(SortBeanWrapper::isModified)
                .map(SortBeanWrapper::getTarget)
                .collect(Collectors.toList());
        //将主动修改的数据添加
        toSaveList.add(newSortBean.getTarget());

        updateConsumer.accept(toSaveList);
    }

    /**
     * 数组长度和排序最大值是否相等
     *
     * @param oneGroup
     * @return
     */
    private boolean needInitSort(List<SortBeanWrapper> oneGroup) {
        Set<Integer> collect = oneGroup.stream().map(SortBeanWrapper::getSort).collect(Collectors.toSet());
        if (collect.size() != oneGroup.size()) {
            return true;
        }

        int maxSort = oneGroup.stream().mapToInt(SortBeanWrapper::getSort).max().getAsInt();
        return oneGroup.size() != maxSort;
    }

    //根据newObj的主键id从列表中获取旧的数据，并从列表中删除
    private SortBeanWrapper takeOldObj(T newObj, Function<T, Long> idFunction, List<SortBeanWrapper> allDataInGroup) {

        Iterator<SortBeanWrapper> iterator = allDataInGroup.iterator();
        while (iterator.hasNext()) {
            SortBeanWrapper item = iterator.next();
            if (idFunction.apply(item.getTarget()).longValue() == idFunction.apply(newObj).longValue()) {
                iterator.remove();
                return item;
            }
        }
        throw new RuntimeException("数据有误，修改失败");
    }

    private void initSort(List<SortBeanWrapper> oneGroup) {
        oneGroup.sort(Comparator.comparing(SortBeanWrapper::getSort));
        for (int i = 0; i < oneGroup.size(); i++) {
            SortBeanWrapper item = oneGroup.get(i);
            if (item.getSort() - 1 != i) {//不需要修改
                item.setSort(i + 1);
            }
        }
    }

    public static int getSort(Object obj) {
        try {
            Field sort = obj.getClass().getDeclaredField("sort");
            sort.setAccessible(true);
            if (ObjectUtils.isEmpty(sort.get(obj))) {
                return 0;
            }
            return Integer.parseInt(String.valueOf(sort.get(obj)));
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return -1;
    }

    public static void setSort(Object obj, int i) {
        try {
            Field sort = obj.getClass().getDeclaredField("sort");
            sort.setAccessible(true);


            if (sort.getType() == Integer.class || sort.getType() == int.class) {
                sort.set(obj, i);
            }
            if (sort.getType() == Long.class || sort.getType() == long.class) {
                sort.set(obj, Long.valueOf(String.valueOf(i)));
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public SortBeanWrapper wrap(T t) {
        return new SortBeanWrapper(t);
    }

    public List<SortBeanWrapper> wrap(List<T> list) {
        return list.stream().map(SortBeanWrapper::new).collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<TestObjPro> list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add(new TestObjPro(i, i + 1));
        }
        list.get(2).setSort(12);
        printIdAndSort(list);
        TestObjPro testObjPro = new TestObjPro(6, 9);
        new UpdateSortPro<TestObjPro>().updateSort(testObjPro,
                () -> list,
                TestObjPro::getA,
                a -> {
                });

        replace(list, testObjPro);

        System.out.printf("sort\t");
        list.forEach(item -> {
            System.out.printf(item.getSort() + "\t");
        });
    }

    private static void replace(List<TestObjPro> list, TestObjPro testObjPro) {
        Iterator<TestObjPro> iterator = list.iterator();
        while (iterator.hasNext()) {
            TestObjPro item = iterator.next();
            if (item.getA() == testObjPro.getA()) {
                iterator.remove();
                break;
            }
        }
        list.add(testObjPro);
        list.sort(Comparator.comparing(TestObjPro::getA));
    }

    private static void printIdAndSort(List<TestObjPro> list) {
        System.out.printf("__id\t");
        list.forEach(item -> {
            System.out.printf(item.getA() + "\t");
        });

        System.out.printf("\nsort\t");
        list.forEach(item -> {
            System.out.printf(item.getSort() + "\t");
        });
        System.out.printf("\n");
    }



    class SortBeanWrapper {
        private T target;
        private Integer oldSort;

        public SortBeanWrapper(T target) {
            this.target = target;
            this.oldSort = UpdateSortPro.getSort(target);
        }

        public int getSort() {
            return UpdateSortPro.getSort(target);
        }

        public void setSort(int sort) {
            UpdateSortPro.setSort(target, sort);
        }

        public T getTarget() {
            return target;
        }

        public boolean isModified() {
            return this.oldSort != getSort();
        }
    }


}

class TestObjPro {
    private Long a;
    private int sort;

    public TestObjPro(long a, int sort) {
        this.a = a;
        this.sort = sort;
    }

    @Override
    public String toString() {
        return "TestObj{" +
                "a=" + a +
                ", sort=" + sort +
                '}';
    }

    public long getA() {
        return a;
    }

    public void setA(long a) {
        this.a = a;
    }

    public int getSort() {
        return sort;
    }

    public void setSort(int sort) {
        this.sort = sort;
    }

}