對List對象集合按照對象多個屬性排序

針對Object對象中屬性排序，可指定多個屬性排序。

注意：若是需要排序的字段是父類中的字段，需要子類重寫該字段和get set方法，否則反射時找不到對應字段。

public class ListSortUtils {



        /**
         * 對list的元素按照多個屬性名稱排序,
         * list元素的屬性可以是數字（byte、short、int、long、float、double等，支持正數、負數、0）、char、String、java.util.Date
         *
         *
         *            list元素的屬性名稱
         * @param isAsc
         *            true升序，false降序
         */
        public static <E> void sort(List<E> list, final boolean isAsc, final String... sortnameArr) {
            Collections.sort(list, new Comparator<E>() {

                @Override
                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降序
         */

        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>() {
                @Override
                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
         * @return
         * @throws Exception
         */
        private static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception {
            int ret;
            Object value1 = ListSortUtils.forceGetFieldValue(a, sortname);
            Object value2 = ListSortUtils.forceGetFieldValue(b, sortname);
            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);
            }
            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().getField(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;
        }
    }

示例：

public static void main(String[] args) {

        List<Person> list = new ArrayList<Person>();
        Person p = new Person();
        p.setAge(25);
        p.setName("高小冷");
        p.setSeniority(4);
        p.setSex("男");

        Person p2 = new Person();
        p2.setAge(25);
        p2.setName("高大冷");
        p2.setSeniority(4);
        p2.setSex("女");

        Person p3 = new Person();
        p3.setAge(27);
        p3.setName("挺熱的");
        p3.setSeniority(6);
        p3.setSex("男");

        list.add(p);
        list.add(p2);
        list.add(p3);

        //針對list多個屬性排序,年齡相同則按照姓名排序
        String[] sortNameArr = {"age", "name"};
        //true升序，false降序
        boolean[] isAscArr = {true, true};
        ListSortUtils.sort(list, sortNameArr, isAscArr);

        System.out.println(list.toString());
  }

--

public class Person {


    public Integer age;
    public String name;
    public String sex;
    //工齡
    public Integer seniority;



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }


    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getSeniority() {
        return seniority;
    }

    public void setSeniority(Integer seniority) {
        this.seniority = seniority;
    }


    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", seniority=" + seniority +
                '}';
    }
}