java物件排序（使用Comparator）

物件屬性為int型別排序

首先我們假設有這麼一個model類：

public class JobCandidate {

    private String name;
    private String sex;
    private int age;

    public JobCandidate(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    /*@Override
    public int compareTo(JobCandidate candidate) {
        return (this.getAge() < candidate.getAge() ? -1 : this.getAge() == candidate.getAge() ? 0 :1);
    }*/
 


    public static Comparator<JobCandidate> ageComparator = new Comparator<JobCandidate>() {

        @Override
        public int compare(JobCandidate jc1, JobCandidate jc2) {
             return (jc2.getAge() < jc1.getAge() ? -1 : (jc2.getAge() == jc1.getAge() ? 0 : 1));
        }
    };

    public
 
 static Comparator<JobCandidate> nameComparator = new Comparator<JobCandidate>() {

        @Override
        public int compare(JobCandidate jc1, JobCandidate jc2) {
            return (jc1.getName().compareTo(jc2.getName()));
        }
    };

    public static Comparator<JobCandidate> nameChina = new
 
 Comparator<JobCandidate>() {

        Collator cmp = Collator.getInstance(java.util.Locale.CHINA);  
        @Override
        public int compare(JobCandidate o1, JobCandidate o2) {

            CollationKey c1 = cmp.getCollationKey(o1.getName());
            CollationKey c2 = cmp.getCollationKey(o2.getName());
            return cmp.compare(c1.getSourceString(), c2.getSourceString());
//          return cmp.compare(o1.getName(), o2.getName());
//          return (o1.getName().compareTo(o2.getName()));
        }
    };

    @Override
    public String toString() {
        return " Name: " + this.name + ", sex: " + this.sex + ", age:" + this.age;
    }

    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 int getAge() {
        return age;
    }

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

}

我們先看ageComparator
上面的類中聲明瞭一個ageComparator靜態變數，其寫了一個匿名類實現了compare()的方法。
要是不想使用匿名類的方式，可以在外部再建立一個類來實現Comparator介面。
接著我再寫一個排序類。也就是你想通過JobCandidate類中那個屬性來排序。

JobCandidate類裡定義了排序方法。

public class JobCandidateSorter {
    ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();

    public JobCandidateSorter(ArrayList<JobCandidate> jobCandidateList) {
        this.jobCandidateList = jobCandidateList;
    }
    //使用Comparable類中compareTo方法來做
    /*public ArrayList<JobCandidate> getSortedJobCandidateByAge() {
        Collections.sort(jobCandidate);
        return jobCandidate;
    }*/

    public ArrayList<JobCandidate> getSortedJobCandidateByAge(){
        Collections.sort(jobCandidateList, JobCandidate.ageComparator);
        return jobCandidateList;
    }

    public ArrayList<JobCandidate> getSortedJobCandidateByName(){
        Collections.sort(jobCandidateList, JobCandidate.nameComparator);
        return jobCandidateList;
    }

    public ArrayList<JobCandidate> getSortedJobCandidateByComparator() {
        Collections.sort(jobCandidateList, JobCandidate.nameChina);
        return jobCandidateList;
    }
}

同樣目前我們只看getSortedJobCandidateByAge()的方法：

Collections.sort(jobCandidateList, JobCandidate.ageComparator);

該方法就是呼叫Collections.sort()方法。
第一個引數就是我們要排序的陣列，
這裡jobCandidateList的是List<jobCandidateList>型別的。
第二個引數：JobCandidate.ageComparator就是我在JobCandidate類中定義 的匿名類。該匿名類重寫了compare()的方法。

@Override
public int compare(JobCandidate jc1, JobCandidate jc2) {
    //jc1>jc2說明是
    return (jc2.getAge() < jc1.getAge() ? -1 : (jc2.getAge() == jc1.getAge() ? 0 : 1));
}

好了我們現在寫個測試類，看看效果：

public class JobCandidateSorterTest {

    public void testGetSortedJobCandidateByAge() throws Exception {
        JobCandidate jobCandidate1 = new JobCandidate("王林", "Male", 26);
        JobCandidate jobCandidate2 = new JobCandidate("楊寶", "Female", 23);
        JobCandidate jobCandidate3 = new JobCandidate("李鎮", "Female", 20);
        JobCandidate jobCandidate4 = new JobCandidate("劉迪", "Male", 24);
        ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();
        jobCandidateList.add(jobCandidate1);
        jobCandidateList.add(jobCandidate2);
        jobCandidateList.add(jobCandidate3);
        jobCandidateList.add(jobCandidate4);
        JobCandidateSorter jobCandidateSorter = new JobCandidateSorter(jobCandidateList);
        ArrayList<JobCandidate> sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge();//呼叫排序方法
        System.out.println("-----Sorted JobCandidate by age: Ascending-----");
        for (JobCandidate jobCandidate : sortedJobCandidate) {
            System.out.println(jobCandidate);
        }

        jobCandidateSorter.getSortedJobCandidateByComparator();//Collator.getInstance(java.util.Locale.CHINA)
        System.out.println(jobCandidateList);
    }

    public static void main(String[] args) throws Exception {
        JobCandidateSorterTest jt = new JobCandidateSorterTest();
        jt.testGetSortedJobCandidateByAge();
    }
}

列印結果

—–排序後的結果—–
Name: 王林, sex: Male, age:26
Name: 劉迪, sex: Male, age:24
Name: 楊寶, sex: Female, age:23
Name: 李鎮, sex: Female, age:20
======未排序====================
[ Name: 李鎮, sex: Female, age:20, Name: 劉迪, sex: Male, age:24, Name: 王林, sex: Male, age:26, Name: 楊寶, sex: Female, age:23]

物件屬性為String的排序

我們接下來看到上面JobCandidate類程式碼中靜態變數nameComparator 。

public static Comparator<JobCandidate> nameComparator = 
new Comparator<JobCandidate>() {

        @Override
        public int compare(JobCandidate jc1, JobCandidate jc2) {
            return (jc1.getName().compareTo(jc2.getName()));
        }
    };

其中Comparable 是帶有單一 compareTo()方法的介面.也就是說要重寫conpareTo()
的方法，得實現comparable類。不重寫的話，就是採用預設的。

以上就是通過物件屬性排序結果，這種排序方式只適合英文排序結果，由於age是數字，結果中英文都一樣。

我們看看name的排序結果：

—–排序後的結果—–
Name: 劉迪, sex: Male, age:24
Name: 李鎮, sex: Female, age:20
Name: 楊寶, sex: Female, age:23
Name: 王林, sex: Male, age:26

這個結果是預設中文字串排序的順序，他們拼音首字母：L L Y W,
我們實際希望按照中國語言的預設順序也就是按照拼音首字母來排序。
希望的正確順序就是：L L Y M。

物件屬性為String的中文排序。

我們接下來看到上面JobCandidate類程式碼中靜態變數nameChina 。

public static Comparator<JobCandidate> nameChina = new Comparator<JobCandidate>() {

        Collator cmp = Collator.getInstance(java.util.Locale.CHINA);  
        @Override
        public int compare(JobCandidate o1, JobCandidate o2) {

//          CollationKey c1 = cmp.getCollationKey(o1.getName());
//          CollationKey c2 = cmp.getCollationKey(o2.getName());
//          return cmp.compare(c1.getSourceString(), c2.getSourceString());
            return cmp.compare(o1.getName(), o2.getName());
        }
    };

—–排序後的結果—–
Name: 李鎮, sex: Female, age:20
Name: 劉迪, sex: Male, age:24
Name: 王林, sex: Male, age:26
Name: 楊寶, sex: Female, age:23

拼音首字母排序：L L W Y 這才是我們想要的。
這裡使用Collator類。在網上我找到這麼一句話：

預設情況下，字串的比較使用字串包含字元的ASCII碼來比較。
java.text.Collator使用字串包含字元在指定語言的自然順序（譬如中文漢字的自然順序）做比較。是locale敏感的。

如果只比較純英文，那麼就不需要使用collator。一般情況下我們直接使用Collections.sort()來執行排序操作、或者根據字元的ASCII碼來排序。但是，如果其中包含一些特殊字元如é、中文漢字，那邊使用collator和預設的collections.sort排序結果並不一致。

也就是說我們要使用中文排序的話，就需要使用Collator類，再調Collator類中的比較方法：compare() 其中compare()方法是Comparator介面的單一的比較方法。

上面程式碼註釋掉的：

            CollationKey c1 = cmp.getCollationKey(o1.getName());
            CollationKey c2 = cmp.getCollationKey(o2.getName());
            return cmp.compare(c1.getSourceString(), c2.getSourceString());

這是另一種寫法而已，依然使用的是Collator類。

java物件排序（使用Comparable）

上面使用的是實現Comparator介面並重寫compare()的方法。
java中還可以實現Comparable的方法並重寫compareTo()的方法來實現排序。

JobCandidate 中程式碼：

public class JobCandidate implements Comparable<JobCandidate>{

    private String name;
    private String sex;
    private int age;

    public JobCandidate(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    @Override
    public int compareTo(JobCandidate candidate) {
        return (this.getAge() < candidate.getAge() ? -1 : this.getAge() == candidate.getAge() ? 0 :1);
    }

    @Override
    public String toString() {
        return " Name: " + this.name + ", sex: " + this.sex + ", age:" + this.age;
    }

    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 int getAge() {
        return age;
    }

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

}

JobCandidateSorter類的程式碼：
這個類就是排序類。裡面定義的都是排序的方法。

public class JobCandidateSorter {
    ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();

    public JobCandidateSorter(ArrayList<JobCandidate> jobCandidateList) {
        this.jobCandidateList = jobCandidateList;
    }
    //使用Comparable類中compareTo方法來做
    public ArrayList<JobCandidate> getSortedJobCandidateByAge() {
        Collections.sort(jobCandidateList);
        return jobCandidateList;
    }
}

測試類JobCandidateSorterTest的程式碼：

public class JobCandidateSorterTest {

    public void testGetSortedJobCandidateByAge() throws Exception {
        JobCandidate jobCandidate1 = new JobCandidate("王林", "Male", 26);
        JobCandidate jobCandidate2 = new JobCandidate("楊寶", "Female", 23);
        JobCandidate jobCandidate3 = new JobCandidate("李鎮", "Female", 20);
        JobCandidate jobCandidate4 = new JobCandidate("劉迪", "Male", 24);
        ArrayList<JobCandidate> jobCandidateList = new ArrayList<JobCandidate>();
        jobCandidateList.add(jobCandidate1);
        jobCandidateList.add(jobCandidate2);
        jobCandidateList.add(jobCandidate3);
        jobCandidateList.add(jobCandidate4);
        JobCandidateSorter jobCandidateSorter = new JobCandidateSorter(jobCandidateList);
        ArrayList<JobCandidate> sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge();
        System.out.println("-----排序後的結果-----");
        for (JobCandidate jobCandidate : sortedJobCandidate) {
            System.out.println(jobCandidate);
        }
    }
    public static void main(String[] args) throws Exception {
        JobCandidateSorterTest jt = new JobCandidateSorterTest();
        jt.testGetSortedJobCandidateByAge();
    }
}

排序結果（age欄位排序）：

—–排序後的結果—–
Name: 李鎮, sex: Female, age:20
Name: 楊寶, sex: Female, age:23
Name: 劉迪, sex: Male, age:24
Name: 王林, sex: Male, age:26

這裡我們會發現小區別：
compare()的方法是傳入兩個引數，也就是兩個相同型別的不同物件。
compareTo()的方法是傳入一個引數，和呼叫該方法的物件是相同型別的。

我重寫的compareTo():

@Override
public int compareTo(JobCandidate candidate) {
    return (this.getAge() < candidate.getAge() ? -1 : this.getAge() == candidate.getAge() ? 0 :1);
    }

如果也想進行中文排序，依然是使用：

Collator cmp = Collator.getInstance(java.util.Locale.CHINA);

再呼叫cmp.compare(o1,o2)的方法來做。

Collections.sort()

Collections.sort()這個排序的關鍵方法。不管你實現Comparable介面還是實現Comparator介面，都得用到該方法。
假設我們實現Comparable的介面，這個呼叫的是：

Collections.sort(List list)

原始碼：

public static <T extends Comparable<? super T>> void sort(List<T> list) {  
    Object[] a = list.toArray();  
    Arrays.sort(a);  
    ListIterator<T> i = list.listIterator();  
    for (int j=0; j<a.length; j++) {  
        i.next();  
        i.set((T)a[j]);  
    }  
}  

此時直接呼叫了Arrays.sort(a)來排序後，將陣列的資料寫回到list，另外根據方法的定義，
泛型T要求傳入的類必須是Comparable類的子類或實現類(我的例子中就是JobCandidate類)，
所以要呼叫Collections.sort(list)這個方法，傳入的list中包含的每行資料必須是implements
Comparable這個介面的，否則編譯時就會報錯。

假設我們實現Comparator的介面，則呼叫的是：

以下轉載內容

Collections.sort(List list, Comparator<? super T> c)

原始碼：

public static <T> void sort(List<T> list, Comparator<? super T> c) {  
    Object[] a = list.toArray();  
    Arrays.sort(a, (Comparator)c);  
    ListIterator i = list.listIterator();  
    for (int j=0; j<a.length; j++) {  
        i.next();  
        i.set(a[j]);  
    }  
}  

也是和第一個方法類似，就是呼叫了Arrays.sort相應的過載方法，看來都是在Arrays裡面是實現的，那麼就進一步向下看：

public static void sort(Object[] a) {  
        Object[] aux = (Object[])a.clone();  
        mergeSort(aux, a, 0, a.length, 0);  
}  

看來程式碼片段交給了mergeSort來處理，而對陣列做了一次克隆，作為排序的基礎資料，而原來的陣列作為排序的目標，mergeSort的程式碼片段應該是核心部分，我們先放在這裡，先看下sort的另一個過載方法，另外需要注意，這裡並沒有像Collections.sort(Listlist)那樣在編譯時檢查型別，也就是在使用這個方法的時候，數組裡面的每行並沒有implements
Comparable也會不會出錯，只是在執行時會報錯而已，在下面的原始碼中會有說明。

Arrays.sort(T[]t, Comparator<? super T> c)

原始碼：

public static <T> void sort(T[] a, Comparator<? super T> c) {  
 aux = (T[])a.clone();  
    if (c==null)  
        mergeSort(aux, a, 0, a.length, 0);  
    else  
        mergeSort(aux, a, 0, a.length, 0, c);  
}  

看來mergeSort也進行了過載，也就是當傳入了自定義的Comparator和不傳入自定義的Comparator是呼叫不同的方法來實現的，然後我們來看下兩個方法的實現。

mergeSort(Object[]src , Object[]dst , int low , int high , int off)

原始碼：

private static void mergeSort(Object[] src,  
                  Object[] dest,  
                  int low,  
                  int high,  
                  int off) {  
    int length = high - low;  
        if (length < INSERTIONSORT_THRESHOLD) {  
            for (int i=low; i<high; i++)  
                for (int j=i; j>low &&  
             ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)  
                    swap(dest, j, j-1);  
            return;  
        }  
        int destLow  = low;  
        int destHigh = high;  
        low  += off;  
        high += off;  
        int mid = (low + high) >>> 1;  
        mergeSort(dest, src, low, mid, -off);  
        mergeSort(dest, src, mid, high, -off);  
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {  
            System.arraycopy(src, low, dest, destLow, length);  
            return;  
        }  
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {  
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)  
                dest[i] = src[p++];  
            else  
                dest[i] = src[q++];  
        }  
    }  

/** 
 * Swaps x[a] with x[b]. 
 */  
private static void swap(Object[] x, int a, int b) {  
    Object t = x[a];  
    x[a] = x[b];  
    x[b] = t;  
}  

仔細閱讀程式碼可以發現排序是分段遞歸回調的方式來排序（注意中間的low和high兩個引數的變化），每次如果分段的大小大於INSERTIONSORT_THRESHOLD（定義為7）的時候，則再分段，前一段和後一段，然後分開的兩段再呼叫遞推，遞推後再回歸排序，若發現中間分隔的位置兩個資料是有序，則認為兩段是完全有序的，若不是，那麼再將兩段做一次排序，此時排序就很好排序了，因為兩個塊是排序排好的，所以不需要兩次迴圈，只需要迴圈掃描下去，兩個陣列按照順序向下走，分別對比出最小值寫入陣列，較大者暫時不寫入陣列與另一個數組的下一個值進行對比，最後一截資料（原始碼中是通過越界來判定的）寫入到尾巴當中：

for(int i = destLow, p = low, q = mid; i < destHigh; i++) {  
       if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)  
           dest[i] = src[p++];  
       else  
           dest[i] = src[q++];  
} 

這段對兩個有序陣列的排序是很經典的寫法，主要是if語句的濃縮，不然程式碼會寫得很長。

注意：這裡的程式碼排序中使用了強制型別轉換為Comparable來呼叫內部的comareTo方法，所以如果你的類沒有implements Comparable那麼在Collections.sort(Listlist)時編譯時會報錯上面已經說到，在呼叫Arrays.sort(Object []t)時，編譯時並不會報錯，但是執行時會報錯為：java.lang.ClassCastExceptionXXXDO cannot be cast to java.lang.Comparable

排序部分我們再看看其過載的mergeSort方法，就是傳入了自定義的Comparator的方法

原始碼片段:mergeSort(Object[]src,Object[]dst,int low,int high,intoff,Comparator c)

private static void mergeSort(Object[] src,  
              Object[] dest,  
              int low, int high, int off,  
              Comparator c) {  
int length = high - low;  
if (length < INSERTIONSORT_THRESHOLD) {  
    for (int i=low; i<high; i++)  
    for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)  
        swap(dest, j, j-1);  
    return;  
}  
       int destLow  = low;  
       int destHigh = high;  
       low  += off;  
       high += off;  
       int mid = (low + high) >>> 1;  
       mergeSort(dest, src, low, mid, -off, c);  
       mergeSort(dest, src, mid, high, -off, c);  


       if (c.compare(src[mid-1], src[mid]) <= 0) {  
          System.arraycopy(src, low, dest, destLow, length);  
          return;  
       }  
       for(int i = destLow, p = low, q = mid; i < destHigh; i++) {  
           if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)  
               dest[i] = src[p++];  
           else  
               dest[i] = src[q++];  
       }  
   }  

可以發現演算法和上一個方法完全一樣，唯一的區別就是排序時使用的compare變成了傳入的comparator了，其餘的沒有任何區別。

大概清楚了，此時發現java提供的排序還是比較高效的，大多數情況下你不需要自己去寫排序演算法，最後我們再看看TreeSet中的在add的時候如何實現排序的，也是分別傳入了comparator和沒有傳入，我們跟著原始碼裡面，可以看到傳入了comparator將這個屬性設定給了TreeSet裡面定義的一個TreeeMap，而TreeMap中的一個屬性設定了這個Comparator：

原始碼片段：TreeSet以及TreeMap設定Comparator的構造方法

public TreeSet(Comparator<? super E> comparator) {  
    this(new TreeMap<E,Object>(comparator));  
}  
TreeSet(NavigableMap<E,Object> m) {  
    this.m = m;  
}  
public TreeMap(Comparator<? super K> comparator) {  
        this.comparator = comparator;  
}  

當然沒有傳入這個Comparator的時候自然沒有設定到TreeMap中了，那麼我們來看看TreeMap的add方法：

原始碼片段：TreeSet#add(E e)

public boolean add(E e) {

    return m.put(e,PRESENT)==null;

}

這個m是什麼呢？其實通過原始碼片段7就可以看出，m是開始例項化的一個TreeMap，那麼我們就需要看TreeMap的put方法

原始碼片段：TreeMap#put(K key , V value)

public V put(K key, V value) {  
        Entry<K,V> t = root;  
        if (t == null) {  
            root = new Entry<K,V>(key, value, null);  
            size = 1;  
            modCount++;  
            return null;  
        }  
        int cmp;  
        Entry<K,V> parent;  
        // split comparator and comparable paths  
        Comparator<? super K> cpr = comparator;  
        if (cpr != null) {  
            do {  
                parent = t;  
                cmp = cpr.compare(key, t.key);  
                if (cmp < 0)  
                    t = t.left;  
                else if (cmp > 0)  
                    t = t.right;  
                else  
                    return t.setValue(value);  
            } while (t != null);  
        }  
        else {  
            if (key == null)  
                throw new NullPointerException();  
            Comparable<? super K> k = (Comparable<? super K>) key;  
            do {  
                parent = t;  
                cmp = k.compareTo(t.key);  
                if (cmp < 0)  
                    t = t.left;  
                else if (cmp > 0)  
                    t = t.right;  
                else  
                    return t.setValue(value);  
            } while (t != null);  
        }  
        Entry<K,V> e = new Entry<K,V>(key, value, parent);  
        if (cmp < 0)  
            parent.left = e;  
        else  
            parent.right = e;  
        fixAfterInsertion(e);  
        size++;  
        modCount++;  
        return null;  
    }  

這裡判定了是否存在Comparator進行不同方式來寫入不同的位置，並沒有過載方法，所以實現上也不一定有什麼絕對非要如何做，只需要保證程式碼可讀性很好就好，一切為它服務，否則那些過多的設計是屬於過度設計，當然並不是說程式碼設計不重要，但是這些需要適可而止；另外TreeSet裡面對於其他的方法也會做排序處理，我們這裡僅僅是用add方法來做一個例子而已。

相信你對java的排序有了一些瞭解，也許本文說了一堆廢話，因為本文不是在說排序演算法，我們只是告訴你java是如何排序的，你在大部分情況下無需自己寫排序演算法來完成排序導致一些不必要的bug，而且效率未必有java本身提供的排序演算法高效。