Java拖拽排序工具类

大家好，欢迎来到IT知识分享网。

package com.ciih.jwt.util.sort;


import java.lang.reflect.Field;
import java.util.Collections;
import java.util.List;

/**
 * 拖拽排序工具:此工具将传入的list重新排序后返回,使用者只需要将list重新存入数据库即可完成排序.
 * <>
 * 拖拽排序必然牵扯到两个元素,被拖拽的元素和被挤压的元素.排序方式就存在两种,一种是两个元素进行交换位置,一种是一个元素拖到另一元素的下发或上方.
 * 1.此方法需要传入两个基准元素之间的所有元素的集合,
 * 2.以及两个基准元素的id,
 * 3.排序方式.
 * </>
 *
 * @author sunziwen
 * @since 2021-3-23 19:15:07
 */
public class SortUtil {
    /**
     * 此方法需要在T类的主键上打@IdProperty注解,在排序字段上打@OrderProperty注解.
     *
     * @param list 需要重新排序的元素集合
     * @param id1  拖拽元素
     * @param id2  定位元素
     * @param type 排序类型(1交换,2挤压排序)
     * @param <T>  泛型
     * @return List<T>
     */
    public static <T> List<T> sort(List<T> list, Object id1, Object id2, SortType type) {
        String idProperty = null;
        String orderProperty = null;
        Field[] declaredFields = list.get(0).getClass().getDeclaredFields();
        for (Field declaredField : declaredFields) {
            IdProperty idAnnotation = declaredField.getAnnotation(IdProperty.class);
            OrderProperty orderAnnotation = declaredField.getAnnotation(OrderProperty.class);
            if (idAnnotation != null) {
                idProperty = declaredField.getName();
            }
            if (orderAnnotation != null) {
                orderProperty = declaredField.getName();
            }
        }
        if (idProperty == null) {
            throw new RuntimeException("没有在主键属性上打@IdProperty注解");
        }
        if (orderProperty == null) {
            throw new RuntimeException("没有在排序属性上打@OrderProperty注解");
        }
        return sort(list, id1, id2, type, idProperty, orderProperty);
    }

    /**
     * @param list          需要重新排序的元素集合
     * @param id1           拖拽元素
     * @param id2           定位元素
     * @param type          排序类型(1交换,2挤压排序)
     * @param idProperty    主键属性名,一般是"id"
     * @param orderProperty 排序属性名
     * @param <T>           泛型
     * @return List<T>
     */
    public static <T> List<T> sort(List<T> list, Object id1, Object id2, SortType type, String idProperty, String orderProperty) {
        //排序
        list.sort((x, y) -> {
            try {
                Field fieldx = x.getClass().getDeclaredField(orderProperty);
                Field fieldy = y.getClass().getDeclaredField(orderProperty);
                fieldx.setAccessible(true);
                fieldy.setAccessible(true);

                int i = Integer.parseInt(fieldx.get(x).toString());
                int j = Integer.parseInt(fieldy.get(y).toString());
                return i - j;
            } catch (IllegalAccessException | NoSuchFieldException e) {
                e.printStackTrace();
                throw new RuntimeException("反射异常了");
            }
        });
        if (list == null || list.size() <= 0) {
            return list;
        }
        //傻子在原地拖动
        if (id1.equals(id2)) {
            return list;
        }

        try {

            T tFirst = list.get(0);
            T tLast = list.get(list.size() - 1);

            Field orderFirst = tFirst.getClass().getDeclaredField(orderProperty);
            orderFirst.setAccessible(true);
            Object orderValueFirst = orderFirst.get(tFirst);

            Field orderLast = tLast.getClass().getDeclaredField(orderProperty);
            orderLast.setAccessible(true);
            Object orderValueLast = orderLast.get(tLast);

            //交换位置
            if (type == SortType.EXCHANGE) {
                orderFirst.set(tFirst, orderValueLast);
                orderLast.set(tLast, orderValueFirst);
            }

            //冒泡排序需要知道是从上往下,还是从下往上拖拽.因此需要知道他们的order值 order1<order2则是从上往下,反之亦然.
            if (type == SortType.BUBBLE) {

                //order集合
                int[] orders = list.stream().mapToInt(x -> {
                    try {
                        Field order = x.getClass().getDeclaredField(orderProperty);
                        order.setAccessible(true);
                        Object orderVal = order.get(x);
                        if (orderVal == null) {
                            throw new RuntimeException("有元素缺失排序属性值");
                        }
                        return Integer.parseInt(orderVal.toString());
                    } catch (NoSuchFieldException | IllegalAccessException e) {
                        e.printStackTrace();
                        throw new RuntimeException("未知异常:联系作者");
                    }
                }).toArray();

                //获取id1和id2的排序值,用来确认是拖拽方向
                Integer order1 = null;
                Integer order2 = null;
                for (T t : list) {
                    Field idField = t.getClass().getDeclaredField(idProperty);
                    idField.setAccessible(true);
                    Object idVal = idField.get(t);
                    if (idVal.equals(id1)) {
                        Field orderField = t.getClass().getDeclaredField(orderProperty);
                        orderField.setAccessible(true);
                        order1 = Integer.parseInt(orderField.get(t).toString());
                    }
                    if (idVal.equals(id2)) {
                        Field orderField = t.getClass().getDeclaredField(orderProperty);
                        orderField.setAccessible(true);
                        order2 = Integer.parseInt(orderField.get(t).toString());
                    }
                }
                if (order1 == null || order2 == null) {
                    throw new RuntimeException("排序字段缺失属性值");
                }
                //从上往下拖拽
                if (order1 < order2) {
                    //将首位元素挪到末尾
                    list.remove(tFirst);
                    list.add(tFirst);

                    //从下往上拖拽
                } else {
                    //将末尾元素追加到首位
                    T last = list.get(list.size() - 1);
                    list.remove(last);
                    Collections.reverse(list);
                    list.add(last);
                    Collections.reverse(list);
                }


                //将元素集合与order集合重新绑定
                for (int i = 0; i < orders.length; i++) {
                    T t = list.get(i);
                    Field order = t.getClass().getDeclaredField(orderProperty);
                    order.setAccessible(true);
                    order.set(t, orders[i]);
                }
            }

        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
            throw new RuntimeException("未知异常:联系作者");
        }
        return list;
    }

}






//@Data
//@AllArgsConstructor
//class User {
//    @IdProperty
//    private Integer id;
//    private String username;
//    private String password;
//    @OrderProperty
//    private Integer order;
//
//    public static void main(String[] args) {
//        ArrayList<User> users = new ArrayList<>();
//        users.add(new User(1, "乔峰", "降龙十八掌", 1));
//        users.add(new User(2, "段誉", "六脉神剑", 2));
//        users.add(new User(3, "虚竹", "北冥神功", 3));
//        users.add(new User(4, "鸠摩智", "小无相功", 4));
//        users.add(new User(5, "慕容复", "斗转星移", 5));
//        users.add(new User(6, "丁春秋", "化功大法", 6));
//        List<User> sort = SortUtil.sort(users, 1, 6, SortType.BUBBLE);
//        sort.sort(Comparator.comparingInt(User::getOrder));
//        sort.forEach(System.out::println);
//    }
//}

package com.ciih.jwt.util.sort;

public enum SortType {
    /**
     * <p>排序方式<p/>
     * <>1交换式</>
     * <>2冒泡式</>
     */
    EXCHANGE(1), BUBBLE(2);
    private Integer status;

    SortType(Integer status) {
        this.status = status;
    }

    public Integer getStatus() {
        return status;
    }
}

package com.ciih.jwt.util.sort;

import java.lang.annotation.*;

/**
 * @author sunziwen
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface IdProperty {
}

package com.ciih.jwt.util.sort;

import java.lang.annotation.*;

/**
 * @author sunziwen
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface OrderProperty {
}