當需要排序的集合或數組不是單純的數字型時，通常可以使用Comparator或Comparable，以簡單的方式實現對象排序或自定義排序。

一、Comparator

強行對某個對象collection進行整體排序的比較函數，可以將Comparator傳遞給Collections.sort或Arrays.sort。

接口方法：

1  /** *//**
2   * @return o1小于、等于或大于o2，分別返回負整數、零或正整數。
3   */
4  int compare(Object o1, Object o2);

 1import java.util.Arrays;
 2import java.util.Comparator;
 3
 4public class SampleComparator implements Comparator {
 5
 6  public int compare(Object o1, Object o2) {
 7    return toInt(o1) - toInt(o2);
 8  }
 9
10  private int toInt(Object o) {
11    String str = (String) o;
12    str = str.replaceAll("一", "1");
13    str = str.replaceAll("二", "2");
14    str = str.replaceAll("三", "3");
15    return Integer.parseInt(str);
16  }
17
18  /** *//**
19   * 測試方法
20   */
21  public static void main(String[] args) {
22    String[] array = new String[] { "一二", "三", "二" };
23    Arrays.sort(array, new SampleComparator());
24    for (int i = 0; i < array.length; i++) {
25      System.out.println(array[i]);
26    }
27  }
28
29}

 二、Comparable

強行對實現它的每個類的對象進行整體排序，實現此接口的對象列表（和數組）可以通過Collections.sort或Arrays.sort進行自動排序。

接口方法：

1  /** *//**
2   * @return 該對象小于、等于或大于指定對象o，分別返回負整數、零或正整數。 
3   */
4  int compareTo(Object o);

 1public class User {
 2
 3  private String id;
 4  private int age;
 5
 6  public User(String id, int age) {
 7    this.id = id;
 8    this.age = age;
 9  }
10
11  public int getAge() {
12    return age;
13  }
14
15  public void setAge(int age) {
16    this.age = age;
17  }
18
19  public String getId() {
20    return id;
21  }
22
23  public void setId(String id) {
24    this.id = id;
25  }
26
27}

 1import java.util.Arrays;
 2
 3public class User implements Comparable {
 4
 5  private String id;
 6  private int age;
 7
 8  public User(String id, int age) {
 9    this.id = id;
10    this.age = age;
11  }
12
13  public int getAge() {
14    return age;
15  }
16
17  public void setAge(int age) {
18    this.age = age;
19  }
20
21  public String getId() {
22    return id;
23  }
24
25  public void setId(String id) {
26    this.id = id;
27  }
28
29  public int compareTo(Object o) {
30    return this.age - ((User) o).getAge();
31  }
32
33  /** *//**
34   * 測試方法
35   */
36  public static void main(String[] args) {
37    User[] users = new User[] { new User("a", 30), new User("b", 20) };
38    Arrays.sort(users);
39    for (int i = 0; i < users.length; i++) {
40      User user = users[i];
41      System.out.println(user.getId() + " " + user.getAge());
42    }
43  }
44
45}

先看一下使用Comparator對User集合實現排序的方式：

 1import java.util.Arrays;
 2import java.util.Comparator;
 3
 4public class UserComparator implements Comparator {
 5
 6  public int compare(Object o1, Object o2) {
 7    return ((User) o1).getAge() - ((User) o2).getAge();
 8  }
 9
10  /** *//**
11   * 測試方法
12   */
13  public static void main(String[] args) {
14    User[] users = new User[] { new User("a", 30), new User("b", 20) };
15    Arrays.sort(users, new UserComparator());
16    for (int i = 0; i < users.length; i++) {
17      User user = users[i];
18      System.out.println(user.getId() + " " + user.getAge());
19    }
20  }
21
22}

一個類實現了Camparable接口則表明這個類的對象之間是可以相互比較的，這個類對象組成的集合就可以直接使用sort方法排序。
Comparator可以看成一種算法的實現，將算法和數據分離，Comparator也可以在下面兩種環境下使用：
1、類的設計師沒有考慮到比較問題而沒有實現Comparable，可以通過Comparator來實現排序而不必改變對象本身
2、可以使用多種排序標準，比如升序、降序等

官方解釋：

public interface Comparable<T>

此接口強行對實現它的每個類的對象進行整體排序。此排序被稱為該類的自然排序，類的 compareTo 方法被稱為它的自然比較方法。

實現此接口的對象列表（和數組）可以通過 Collections.sort（和 Arrays.sort）進行自動排序。實現此接口的對象可以用作有序映射表中的鍵或有序集合中的元素，無需指定比較器。

對于類 C 的每一個 e1 和 e2 來說，當且僅當 (e1.compareTo((Object)e2) == 0) 與 e1.equals((Object)e2) 具有相同的布爾值時，類 C 的自然排序才叫做與 equals 一致。注意，null 不是任何類的實例，即使 e.equals(null) 返回 false，e.compareTo(null) 也會拋出 NullPointerException。

強烈推薦（雖然不是必需的）使自然排序與 equals 一致。這是因為在使用其自然排序與 equals 不一致的元素（或鍵）時，沒有顯式比較器的有序集合（和有序映射表）行為表現“怪異”。尤其是，這樣的有序集合（或有序映射表）違背了根據 equals 方法定義的集合（或映射表）的常規協定。

例如，如果將兩個鍵 a 和 b 添加到一個沒有使用顯式比較器的有序集合中，使得 (!a.equals((Object)b) && a.compareTo((Object)b) == 0)，則第二個 add 操作返回 false（有序集合的大小沒有增加），因為從有序集合的角度來看，a 和 b 是等效的。

實際上，所有執行比較的 Java 核心類都具有 equals 一致的自然排序。java.math.BigDecimal 是個例外，它的自然排序把值相等但精確度不同的 BigDecimal 對象（比如 4.0 和 4.00）等同起來。

為了向數學上傾斜，在給定 C 類的基礎上定義自然排序的關系 如下：

      {(x, y) such that x.compareTo((Object)y) <= 0}。

整體排序的 quotient 是：

      {(x, y) such that x.compareTo((Object)y) == 0}。

它直接遵循 compareTo 的協定，商是 C 的等價關系，自然排序是 C的整體排序。當我們說類的自然排序與 equals 一致 時，是指自然排序的商是由類的 equals(Object) 方法定義的等價關系。

    {(x, y) such that x.equals((Object)y)}。

======================================================

public interface Comparator<T>


比較函數強行對某些對象 collection 進行整體排序。可以將 Comparator 傳遞給 sort 方法（如 Collections.sort），從而允許在排序順序上實現精確控制。還可以使用 Comparator 來控制某些數據結構（如 TreeSet 或 TreeMap）的順序。
當且僅當對于一組元素 S 中的每個 e1 和 e2 而言，(compare((Object)e1, (Object)e2)==0) 與 e1.equals((Object)e2) 具有相等的布爾值時，Comparator c 強行對 S 進行的排序才叫做與等號一致 的排序。
當使用具有與等號一致的強行排序能力的 comparator 對有序 set（或有序映射）進行排序時，應該小心謹慎。假定一個帶有顯式 Comparator c 的有序 set（或有序映射）與從 set S 中抽取出來的元素（或鍵）一起使用。如果 c 強行對 S 進行的排序與等號一致，那么有序 set（或有序映射）將是行為“怪異的”。尤其是那些將違背根據 equals 所定義 set（或映射）的常規協定的有序 set（或有序映射）。
例如，如果使用 comparator c 將滿足 (a.equals((Object)b) && c.compare((Object)a, (Object)b) != 0) 的兩個鍵 a 和 b 添加到有序 set 中，則第二個 add 操作將返回 false（有序 set 的大小沒有增加），因為從有序 set 的角度來看，a 和 b 是相等的。
注：通常用 comparator 來實現 java.io.Serializable 是一個好主意，因為它們在可序列化的數據結構（像 TreeSet、TreeMap）中可用作排序方法。為了成功地序列化數據結構，comparator（如果已提供）必須實現 Serializable。
在算術上，定義給定 comparator c 對給定對象 set S 強行實施整體排序 的關系式 為：
       {(x, y) such that c.compare((Object)x, (Object)y) <= 0}.

整體排序的商 是：
       {(x, y) such that c.compare((Object)x, (Object)y) == 0}.

它直接遵循 compare 的協定，商是 S 上的等價關系，自然順序是 S 上的整體排序。當我們說 c 強行對 S 的排序是與等號一致 時，意思是說自然排序的商是對象的 equals(Object) 方法所定義的等價關系：
       {(x, y) such that x.equals((Object)y)}.