當需要排序的集合或數組不是單純的數字型時，通常可以使用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);假設對象User，需要按年齡排序：
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和Comparable的區別
先看一下使用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)}.
