Java：集合，對列表（List）中的自定義對象按屬性（字段）排序（正序、倒序）的方法

1. 要求

對列表（List）中的自定義對象，要求能夠按照對象的屬性（字段）進行排序（正序、倒序）。

如：用戶對象（Member）有用戶名（username）、級別（level）、出生日期（birthday）等字段，要求可以分別對它的三個字段進行排序。

2. 實現思路

1. 對於自定義對象，可以在自定義對象中實現Comparable接口，然后再調用Collections.sort的方法實現排序，只能是針對一個屬性（字段），維持一個順序；要實多字段任意選擇一個排序，同樣需要通過調用Collections.sort(List<T> list, Comparator<? super T> c)方法，傳進一個Comparator來實現。

2. 為避免上述步驟中復雜且重復的代碼，可以寫一個通用的排序類，能夠對自定義對象，針對不同的屬性（字段），實現排序（正序、倒序）。

3. 實現代碼

Member類

package com.clzhang.sample.collections;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 測試用實體類
 * @author acer
 *
 */
public class Member implements Comparable<Member>{
    // 格式化日期用
    private static final SimpleDateFormat MY_SDF = new SimpleDateFormat(
            "yyyy-MM-dd");
    
    // 幾個屬性
    private int id;
    private String username;
    private int level;
    private Date birthday;
    
    // 構造函數
    public Member(int id, String username, int level, String birthday) throws Exception {
        this.id = id;
        this.username = username;
        this.level = level;
        this.birthday = new Date(MY_SDF.parse(birthday).getTime());
    }
    
    // Getters
    public String getUsername() {
        return username;
    }

    public int getLevel() {
        return level;
    }

    public Date getBirthday() {
        return birthday;
    }
    
    // 返回打印用
    @Override
    public String toString() {
        return id + "|" + username + "|" + level + "|" + MY_SDF.format(birthday);
    }
    
    // 注意：如果使用MySortList類，則此方法不再需要。因為此方法是提供給Collections.sort方法使用的。
    @Override
    public int compareTo(Member m) {
        // 只能對一個字段做比較，如果做整個對象的比較就實現不了按指定字段排序了。
        return this.getUsername().compareTo(m.getUsername());
    }
}

MySortList類

package com.clzhang.sample.collections;

import java.util.*;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;

/**
 * 這是一個自定義排序的類，專門針對列表（List）中的數據進行排序；可按指定方法進行。
 * 目前實現對字符串（String）、日期（Date）、整型（Integer）等三種對象進行排序。
 * @author acer
 *
 * @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 {
                        // 目前尚不支持的對象，直接轉換為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;
            }
        });
    }

    // 測試函數
    public static void main(String[] args) throws Exception {
        // 生成自定義對象，然后對它按照指定字段排序
        List<Member> listMember = new ArrayList<Member>();
        listMember.add(new Member(1, "wm123", 3, "1992-12-01"));
        listMember.add(new Member(2, "a234", 8, "1995-12-01"));
        listMember.add(new Member(3, "m456", 12, "1990-12-01"));
        System.out.println("Member當前順序...");
        System.out.println(listMember);
        
        // 方式一排序輸出
        System.out.println("Member默認排序（用自帶的compareTo方法）后...");
        Collections.sort(listMember);
        System.out.println(listMember);
        System.out.println("Member倒序（用自帶的compareTo方法）后...");
        Collections.sort(listMember, Collections.reverseOrder());
        System.out.println(listMember);
        
        // 方式二排序輸出
        MySortList<Member> msList = new MySortList<Member>();
        msList.sortByMethod(listMember, "getUsername", false);
        System.out.println("Member按字段用戶名排序后...");
        System.out.println(listMember);

        msList.sortByMethod(listMember, "getLevel", false);
        System.out.println("Member按字段級別排序后...");
        System.out.println(listMember);

        msList.sortByMethod(listMember, "getBirthday", true);
        System.out.println("Member按字段出生日期倒序后...");
        System.out.println(listMember);
    }
}

輸出：

Member當前順序...
[1|wm123|3|1992-12-01, 2|a234|8|1995-12-01, 3|m456|12|1990-12-01]
Member默認排序（用自帶的compareTo方法）后...
[2|a234|8|1995-12-01, 3|m456|12|1990-12-01, 1|wm123|3|1992-12-01]
Member倒序（用自帶的compareTo方法）后...
[1|wm123|3|1992-12-01, 3|m456|12|1990-12-01, 2|a234|8|1995-12-01]
Member按字段用戶名排序后...
[2|a234|8|1995-12-01, 3|m456|12|1990-12-01, 1|wm123|3|1992-12-01]
Member按字段級別排序后...
[1|wm123|3|1992-12-01, 2|a234|8|1995-12-01, 3|m456|12|1990-12-01]
Member按字段出生日期倒序后...
[2|a234|8|1995-12-01, 1|wm123|3|1992-12-01, 3|m456|12|1990-12-01]