Java List 按某字段排序

程序员零花钱码上见 

List 按某字段排序 代码支持：字符串（String）、日期（Date）、整型（Integer）、整形（Long）

使用场景：将list集合中的数据 按照某个字段进行排序，比如按日期排序倒叙排序或者顺序排序

注意：调用方法

        MySortList<StatChargingDto> msList = new MySortList<StatChargingDto>();  //工具类
        msList.sortByMethod(listMember, "getChargingStationCount", false);//调用

        listMember：需要排序的数据list集合

       “getChargingStationCount” 是排序字段（实体类的对应字段的get方法）

        false：顺序，true:倒叙

package com.eileen.feng.dto.stat;

/**
 * Created by Xuefeng_Wen on 2017/9/5.
 */
public class StatChargingDto{


    private java.lang.String code;


    private java.lang.String name;


    private Long chargingStationCount;

    // END

    public StatChargingDto() {
    }

    public StatChargingDto(String code, String name, Long chargingStationCount) {
        this.code = code;
        this.name = name;
        this.chargingStationCount = chargingStationCount;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

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

    public Long getChargingStationCount() {
        return chargingStationCount;
    }

    public void setChargingStationCount(Long chargingStationCount) {
        this.chargingStationCount = chargingStationCount;
    }
}

/**
 * 这是一个自定义排序的类，专门针对列表（List）中的数据进行排序；可按指定方法进行。
 * 目前实现对字符串（String）、日期（Date）、整型（Integer）、整形（Long） 等四种对象进行排序。
 * @author Xuefeng_Wen
 *
 * @param <E>
 */
public class MySortList<E> {

    /**
     * 对列表中的数据按指定字段进行排序。要求类必须有相关的方法返回字符串、整型、日期等值以进行比较。
     * @param list
     * @param method
     * @param reverseFlag
     */
    public void sortByMethod(List<E> list, final String method, final boolean reverseFlag) {
        Collections.sort(list, new Comparator<Object>() {
            @SuppressWarnings("unchecked")
            public int compare(Object arg1, Object arg2) {
                int result = 0;
                try {
                    Method m1 = ((E) arg1).getClass().getMethod(method, null);
                    Method m2 = ((E) arg2).getClass().getMethod(method, null);
                    Object obj1 = m1.invoke(((E)arg1), null);
                    Object obj2 = m2.invoke(((E)arg2), null);
                    if(obj1 instanceof String) {
                        // 字符串
                        result = obj1.toString().compareTo(obj2.toString());
                    }else if(obj1 instanceof Date) {
                        // 日期
                        long l = ((Date)obj1).getTime() - ((Date)obj2).getTime();
                        if(l > 0) {
                            result = 1;
                        }else if(l < 0) {
                            result = -1;
                        }else {
                            result = 0;
                        }
                    }else if(obj1 instanceof Integer) {
                        // 整型（Method的返回参数可以是int的，因为JDK1.5之后，Integer与int可以自动转换了）
                        result = (Integer)obj1 - (Integer)obj2;
                    }else if(obj1 instanceof Long) {
                        // 整型（Method的返回参数可以是Long的）
                        Long o1 = (Long)obj1;
                        Long o2 = (Long)obj2;
                        result = Integer.parseInt(o1.toString()) - Integer.parseInt(o2.toString());
                    }else {
                        // 目前尚不支持的对象，直接转换为String，然后比较，后果未知
                        result = obj1.toString().compareTo(obj2.toString());

                        System.err.println("MySortList.sortByMethod方法接受到不可识别的对象类型，转换为字符串后比较返回...");
                    }

                    if (reverseFlag) {
                        // 倒序
                        result = -result;
                    }
                } catch (NoSuchMethodException nsme) {
                    nsme.printStackTrace();
                } catch (IllegalAccessException iae) {
                    iae.printStackTrace();
                } catch (InvocationTargetException ite) {
                    ite.printStackTrace();
                }

                return result;
            }
        });
    }

    // 测试函数   false 正序   true 倒叙
    public static void main(String[] args) throws Exception {
        // 生成自定义对象，然后对它按照指定字段排序
        List<StatChargingDto> listMember = new ArrayList<StatChargingDto>();
        listMember.add(new StatChargingDto("11","111",1l));
        listMember.add(new StatChargingDto("22","222",11l));
        listMember.add(new StatChargingDto("33","333",11l));
        System.out.println("Member当前顺序...");
        System.out.println(listMember);

        MySortList<StatChargingDto> msList = new MySortList<StatChargingDto>();
        msList.sortByMethod(listMember, "getChargingStationCount", false);
        System.out.println("Member按字段数量排序后...");
        System.out.println(listMember);

    }
}