Java对List Object按照对象属性进行自定义排序

 注意：如果需要对比两个查询结果的排序，假如数据次序不一致如：List1<->List2 ;             主要原因是SQL中存在 Order By 语句，去除掉或者List1；List2同时添加一致 的 Order By语句即可。

public class ListSortUtils {
    /**
     * 对list的元素按照多个属性名称排序
     *
     * @param list
     * @param isAsc true升序，false降序
     * @param sortnameArr 参数数组
     * @param <E>
     */
    public static <E> void sort(List<E> list, final boolean isAsc, final String... sortnameArr) {
        Collections.sort(list, new Comparator<E>() {
            public int compare(E a, E b) {
                int ret = 0;
                try {
                    for (int i = 0; i < sortnameArr.length; i++) {
                        ret = ListSortUtils.compareObject(sortnameArr[i], isAsc, a, b);
                        if (0 != ret) {
                            break;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return ret;
            }
        });
    }

    /**
     * 给list的每个属性都指定是升序还是降序
     *
     * @param list
     * @param sortnameArr 参数数组
     * @param typeArr     每个属性对应的升降序数组， true升序，false降序
     * @param <E>
     */
    public static <E> void sort(List<E> list, final String[] sortnameArr, final boolean[] typeArr) {
        if (sortnameArr.length != typeArr.length) {
            throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");
        }
        Collections.sort(list, new Comparator<E>() {

            public int compare(E a, E b) {
                int ret = 0;
                try {
                    for (int i = 0; i < sortnameArr.length; i++) {
                        ret = ListSortUtils.compareObject(sortnameArr[i], typeArr[i], a, b);
                        if (0 != ret) {
                            break;
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return ret;
            }
        });
    }

    /**
     * 对2个对象按照指定属性名称进行排序
     * @param sortname 属性名称
     * @param isAsc true升序，false降序
     * @param a
     * @param b
     * @param <E>
     * @return
     * @throws Exception
     */
    private static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception {
        if(sortname == null){
            return 0;
        }
        int ret;
        Object value1 = ListSortUtils.forceGetFieldValue(a, sortname);
        Object value2 = ListSortUtils.forceGetFieldValue(b, sortname);
        if(value1 == null || value2 == null){
            return 0;
        }
        String str1 = value1.toString();
        String str2 = value2.toString();
        if (value1 instanceof Number && value2 instanceof Number) {
            int maxlen = Math.max(str1.length(), str2.length());
            str1 = ListSortUtils.addZero2Str((Number) value1, maxlen);
            str2 = ListSortUtils.addZero2Str((Number) value2, maxlen);
        } else if (value1 instanceof Date && value2 instanceof Date) {
            long time1 = ((Date) value1).getTime();
            long time2 = ((Date) value2).getTime();
            int maxlen = Long.toString(Math.max(time1, time2)).length();
            str1 = ListSortUtils.addZero2Str(time1, maxlen);
            str2 = ListSortUtils.addZero2Str(time2, maxlen);
        }
        /**
　　　　　* 升序排的话就是第一个参数.compareTo(第二个参数);
　　　　　* 降序排的话就是第二个参数.compareTo(第一个参数);
         * compare方法决定排序的升序降序问题 
         * (https://blog.csdn.net/qq_28863045/article/details/79967749)
　　　　　*/  
        if (isAsc) {
            ret = str1.compareTo(str2);
        } else {
            ret = str2.compareTo(str1);
        }
        return ret;
    }

    /**
     * 给数字对象按照指定长度在左侧补0
     * 使用案例: addZero2Str(11,4) 返回 "0011", addZero2Str(-18,6)返回 "-000018"
     *
     * @param numObj
     * @param length
     * @return
     */
    public static String addZero2Str(Number numObj, int length) {
        NumberFormat nf = NumberFormat.getInstance();
        // 设置是否使用分组
        nf.setGroupingUsed(false);
        // 设置最大整数位数
        nf.setMaximumIntegerDigits(length);
        // 设置最小整数位数
        nf.setMinimumIntegerDigits(length);
        return nf.format(numObj);
    }

    /**
     * 获取指定对象的指定属性值（去除private,protected的限制）
     *
     * @param obj  属性名称所在的对象
     * @param fieldName 属性名称
     * @return
     * @throws Exception
     */
    public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        Object object = null;
        boolean accessible = field.isAccessible();
        if (!accessible) {
            // 如果是private,protected修饰的属性，需要修改为可以访问的
            field.setAccessible(true);
            object = field.get(obj);
            // 还原private,protected属性的访问性质
            field.setAccessible(accessible);
            return object;
        }
        object = field.get(obj);
        return object;
    }

}

参考：java Comparator接口中（底层源码）compare方法决定排序的升序降序问题

          Java中Collections.sort()排序详解

写法举例：

String [] sortName = {"属性1","属性2",......};
//排序:true->代表升序；false ->代表降序
boolean [] isAscArr = {true,false,......};
ListSortUtils.sort(list,sortName,isAscArr);

 测试代码：

public static void main(String[] args) {
    Dept dept1=new Dept();
    dept1.setLevel(1);
    dept1.setCode("1");
    dept1.setOrderId(4);
    dept1.setName("一号");
    Dept dept2=new Dept();
    dept2.setLevel(1);
    dept2.setCode("2");
    dept2.setOrderId(3);
    dept2.setName("二号");
    Dept dept3=new Dept();
    dept3.setLevel(1);
    dept3.setCode("3");
    dept3.setOrderId(2);
    dept3.setName("三号");
    Dept dept4=new Dept();
    dept4.setLevel(1);
    dept4.setCode("4");
    dept4.setOrderId(1);
    dept4.setName("四号");

    List<Dept> list=new ArrayList<>();
    list.add(dept1);
    list.add(dept2);
    list.add(dept3);
    list.add(dept4);

    for (Dept dept:list){
         System.out.println("level="+dept.getLevel()+"      code="+dept.getCode()+"      orderId="+dept.getOrderId()+"      name="+dept.getName());
    }

    System.out.println("#################################################################################");
    String [] sortNameArrSHWQ = {"level","code","orderId"};
    //排序:true->代表升序；false ->代表降序
    boolean [] isAscArrSHWQ = {true,true,true};
    ListSortUtils.sort(list,sortNameArrSHWQ,isAscArrSHWQ);

    for (Dept dept:list){
        System.out.println("level="+dept.getLevel()+"      code="+dept.getCode()+"      orderId="+dept.getOrderId()+"      name="+dept.getName());
    }