比如：你想對整數採用絕對值大小來排序，Integer 是不符合要求的，你不需要去修改 Integer 類（實際上你也不能這麼做）去改變它的排序行為，只要使用一個實現了 Comparator 介面的物件來實現控制它的排序就行了。

Collections.sort((List<T> list, Comparator<? super T> c)是用來對list排序

兩種方法各有優劣, 用Comparable 簡單, 只要實現Comparable 介面的物件直接就成為一個可以比較的物件,但是需要修改原始碼, 用Comparator 的好處是不需要修改原始碼, 而是另外實現一個比較器, 當某個自定義的物件需要作比較的時候,把比較器和物件一起傳遞過去就可以比大小了, 並且在Comparator 裡面使用者可以自己實現複雜的可以通用的邏輯,使其可以匹配一些比較簡單的物件,那樣就可以節省很多重複勞動了。

Comparable

Comparable 定義在 Person類的內部:

public class Persion implements Comparable {..比較Person的大小..},

 因為已經實現了比較器,那麼我們的Person現在是一個可以比較大小的物件了,它的比較功能和String完全一樣,可以隨時隨地的拿來
比較大小,因為Person現在自身就是有大小之分的。Collections.sort(personList)可以得到正確的結果。

Comparator

Comparator 是定義在Person的外部的, 此時我們的Person類的結構不需要有任何變化,如

public class Person{ String name; int age },

然後我們另外定義一個比較器:

public PersonComparator implements Comparator() {..比較Person的大小..},

在PersonComparator裡面實現了怎麼比較兩個Person的大小. 所以,用這種方法,當我們要對一個 personList進行排序的時候, 
我們除了了要傳遞personList過去, 還需要把PersonComparator傳遞過去,因為怎麼比較Person的大小是在PersonComparator
裡面實現的, 如:

Collections.sort( personList , new PersonComparator() ).

Arrays.sort(T[], Comparator < ? super T > c) 方法用於物件陣列按使用者自定義規則排序.

使用策略模式
這是策略模式(Strategy pattern)的一個完美又簡潔的示例,值得一提的是為什麼這種場景下適合使用策略模式.
總體來說,策略模式允許在程式執行時選擇不同的演算法.比如在排序時,傳入不同的比較器(Comparator),就採用不同的演算法.
根據上面的例子,假設你想要根據Dog的重量來進行排序,可以像下面這樣,建立一個新的比較器來進行排序:

1. class Dog{  
2.     int size;  
3.     int weight;  
4.     public Dog(int s, int w){  
5.         size = s;  
6.         weight = w;   
7.     }  
8. }  
9. class DogSizeComparator implements Comparator<Dog>{  
10.     @Override
11.     publicint compare(Dog o1, Dog o2) {  
12.         return o1.size - o2.size;  
13.     }  
14. }  
15. class DogWeightComparator implements Comparator<Dog>{  
16.     @Override
17.     publicint compare(Dog o1, Dog o2) {  
18.         return o1.weight - o2.weight;  
19.     }  
20. }  
21. publicclass ArraySort {  
22.     publicstaticvoid main(String[] args) {  
23.         Dog d1 = new Dog(2, 50);  
24.         Dog d2 = new Dog(1, 30);  
25.         Dog d3 = new Dog(3, 40);  
26.         Dog[] dogArray = {d1, d2, d3};  
27.         printDogs(dogArray);  
28.         Arrays.sort(dogArray, new DogSizeComparator());   
29.         printDogs(dogArray);  
30.         Arrays.sort(dogArray, new DogWeightComparator());     
31.         printDogs(dogArray);  
32.     }  
33.     publicstaticvoid printDogs(Dog[] dogs){  
34.         for(Dog d: dogs)  
35.             System.out.print("size="+d.size + " weight=" + d.weight + " ");  
36.         System.out.println();  
37.     }  
38. }  

1. size=2 weight=50 size=1 weight=30 size=3 weight=40  
2. size=1 weight=30 size=2 weight=50 size=3 weight=40  
3. size=1 weight=30 size=3 weight=40 size=2 weight=50  

1. import java.util.Arrays;  
2. import java.util.Comparator;  
3. class Animal{  
4.     int size;  
5. }  
6. class Dog extends Animal{  
7.     public Dog(int s){  
8.         size = s;  
9.     }  
10. }  
11. class Cat extends Animal{  
12.     public Cat(int s){  
13.         size  = s;  
14.     }  
15. }  
16. class AnimalSizeComparator implements Comparator<Animal>{  
17.     @Override
18.     publicint compare(Animal o1, Animal o2) {  
19.         return o1.size - o2.size;  
20.     }  
21.     //in this way, all sub classes of Animal can use this comparator.
22. }  
23. publicclass ArraySort {  
24.     publicstaticvoid main(String[] args) {  
25.         Dog d1 = new Dog(2);  
26.         Dog d2 = new Dog(1);  
27.         Dog d3 = new Dog(3);  
28.         Dog[] dogArray = {d1, d2, d3};  
29.         printDogs(dogArray);  
30.         Arrays.sort(dogArray, new AnimalSizeComparator());    
31.         printDogs(dogArray);  
32.         System.out.println();  
33.         //when you have an array of Cat, same Comparator can be used. 
34.         Cat c1 = new Cat(2);  
35.         Cat c2 = new Cat(1);  
36.         Cat c3 = new Cat(3);  
37.         Cat[] catArray = {c1, c2, c3};  
38.         printDogs(catArray);  
39.         Arrays.sort(catArray, new AnimalSizeComparator());    
40.         printDogs(catArray);  
41.     }  
42.     publicstaticvoid printDogs(Animal[] animals){  
43.         for(Animal a: animals)  
44.             System.out.print("size="+a.size + " ");  
45.         System.out.println();  
46.     }  
47. }  

1. size=2 size=1 size=3  
2. size=1 size=2 size=3  
3. size=2 size=1 size=3  
4. size=1 size=2 size=3  

1. 通用: super 類
2. 策略設計模式(strategy pattern);
3. 歸併排序(merge sort): 時間複雜度 n*log(n);
4. Java.util.Collections#sort(List < T > list, Comparator < ? super T > c)與Arrays.sort 使用類似的思想.