List<T> 属性排序

0.背景

由于需要，按照不同字段对List中对象进行排序，就学习了下反射和JDK中相关接口就写了个排序工具类。目前支持对象属性排序：字符串类型，Integer、Long基本类型的排序。如果需要其它类型比较可以根据自己需求进行扩展。

1

public class ListSortUtil {

    private static Object getValue(Object ob, final String strField) {
        try {
            Field field = ob.getClass().getDeclaredField(strField);
            field.setAccessible(true);
            return field.get(ob);
        } catch (Exception ex) {
            System.out.print(ex.getMessage());
        }
        return null;
    }

    /**
     * field 是要排序的字段
     * 默认是升序,只能比较字符串和Integer和Long
     */
    public static <T> void sort(List<T> src, final String field, final OrderType orderType) {
        Collections.sort(src, new Comparator<T>() {
            @Override
            public int compare(T o1, T o2) {
                Object value1 = getValue(o1, field);
                Object value2 = getValue(o2, field);
                if (value1 == null || value2 == null) {
                    throw new RuntimeException("field字段为空");
                }
                int value = 0;
                if (value1 instanceof String || value2 instanceof String) {
                    value = String.valueOf(value1).compareTo(String.valueOf(value2));
                } else if ((value1 instanceof Integer || value1 instanceof Long) &&
                        (value2 instanceof Integer || value2 instanceof Long)) {
                    value = Long.valueOf(value1.toString()).compareTo(Long.valueOf(value2.toString()));
                }

                if (OrderType.DESC.equals(orderType)) {
                    return -value;
                }
                return value;
            }
        });
    }


}

升序或者降序的枚举类

public enum OrderType {
    DESC(1, "降序"),
    ASC(2, "升序");
    /**
     * 类型值
     */
    private Integer value;
    /**
     * 描述
     */
    private String desc;

    private OrderType(Integer value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    public Integer getValue() {
        return value;
    }

    public String getDesc() {
        return desc;
    }
}

bean对象

public class Student {
    private String name;
    private Integer age;

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

测试程序

public class TestMain {
    public static void main(String[] args) {
        List<Student> students=new ArrayList();
        students.add(new Student("abc",15));
        students.add(new Student("bac",19));
        students.add(new Student("aac",18));
        System.out.println("--按照age降序---");
        ListSortUtil.sort(students,"age",OrderType.DESC);
        print(students);
        System.out.println("--按照name升序---");
        ListSortUtil.sort(students,"name",OrderType.ASC);
        print(students);

    }
    public static void print(List<Student> students)
    {
        for(Student student:students)
        {
            System.out.println(student.toString());
        }
    }
}

输出：

--按照age降序---
Student{name='bac', age=19}
Student{name='aac', age=18}
Student{name='abc', age=15}
--按照name升序---
Student{name='aac', age=18}
Student{name='abc', age=15}
Student{name='bac', age=19}