Java的Comparable與Comparator接口詳解

對集合或數組進行排序有兩種方法：

1.集合中的對象所屬的類實現了java.lang.Comparable 接口，然后調用Collections.sort()或者Arrays.sort()
2.實現java.lang.Comparator接口，把這個實現接口的類作為參數傳遞給上述的sort()方法。

先看Comparable<T>

java.lang 
Interface Comparable<T>

屬於Java集合框架下的一個接口。它只有一個方法 int compareTo(T o) 用於提供排序所需要的比較邏輯。

實現這個接口的類，其對象都可以通過調用Collections.sort()或者Arrays.sort()進行排序，根據compareTo的邏輯升序排列。

/*
 * 方便起見省略getter&setting，主要演示接口作用。 
        這種實現並不嚴謹，因為沒有覆蓋 equals() 和 hashCode()，原因后面描述。       
        這個接口的作用：如果數組或者集合中的（類）元素實現了該接口的話 ,       
        可以調用 Collections.sort 和 Arrays.sort 排序，或應用於有序集合 TreeSet 和 TreeMap 中。 
 * 
 */
public class Person implements Comparable<Person> {
    public int id;
    public String name;
    
    public Person(int id,String name){
        this.id=id;
        this.name = name;
    }

    public String toString(){
        return "Person: "+id+" , "+name;
    }
    
    /*
     * 實現 Comparable 接口的抽象方法，定義排序規則
     *  this < obj 返回負
        this = obj 返回 0
        this > obj 返回正
     * @see java.lang.Comparable#compareTo(java.lang.Object)
     */
    @Override
    public int compareTo(Person o) {
        // TODO Auto-generated method stub
        return this.id - o.id;
    }    
}

 

測試類

public class TestComparable {

    private static Person p1 = new Person(301,"a");
    private static Person p2 = new Person(100,"e");
    private static Person p3 = new Person(101,"d");
    private static Person p4 = new Person(143,"f");
    private static Person p5 = new Person(139,"b");
    private static Person p6 = new Person(113,"c");
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Person> persons = new ArrayList<Person>();
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        persons.add(p5);
        persons.add(p6);
        
        Collections.sort(persons);
        System.out.println("--------------Result 1-----------------");
        for(Person p : persons){
            System.out.println(p.toString());
        }
        
        TreeSet<Person> personSet = new TreeSet<Person>(); 
        personSet.add(p1);
        personSet.add(p2);
        personSet.add(p3);
        personSet.add(p4);
        personSet.add(p5);
        personSet.add(p6);
        
        System.out.println("---------------Result 2----------------");
        for(Person p : personSet){
            System.out.println(p.toString());
        }
        
        Collections.sort(persons, new PersonComparator()); 
        System.out.println("---------------Result 3----------------");
        for(Person p :persons){
            System.out.println(p.toString());
        }
        
    }

}

輸出：

--------------Result 1-----------------
Person: 100 , e
Person: 101 , d
Person: 113 , c
Person: 139 , b
Person: 143 , f
Person: 301 , a
---------------Result 2----------------
Person: 100 , e
Person: 101 , d
Person: 113 , c
Person: 139 , b
Person: 143 , f
Person: 301 , a
---------------Result 3----------------
Person: 301 , a
Person: 139 , b
Person: 113 , c
Person: 101 , d
Person: 100 , e
Person: 143 , f

Result 1是調用了Collections.sort()，而Result 2則是集合本身有序(Sorted Set/Sorted Map)，例如TreeMap和TreeSet。使用非常簡單。

 

值得注意的有以下兩點：

1. 注意BigDecimal。所有實現 Comparable 的 Java 核心類都具有與 equals 一致的自然排序。java.math.BigDecimal 是個例外，它的自然排序將值相等但精確度不同的 BigDecimal 對象（比如 4.0 和 4.00）視為相等。

public class Salary implements Comparable<Salary> {
    
    private BigDecimal money;
    
    public Salary(BigDecimal money){
        this.money = money;
    }
    
    public String toString(){
        return this.money.toString();
    }

    @Override
    public int compareTo(Salary o) {

        return this.money.compareTo(o.money);
        //Do NOT use: return (this.money.subtract(o.money)).intValue();
    }

    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TreeSet<Salary> salarySet = new TreeSet<Salary>();
        salarySet.add(new Salary(new BigDecimal(100.23)));
        salarySet.add(new Salary(new BigDecimal(100.01)));
        salarySet.add(new Salary(new BigDecimal(100.21009)));
        salarySet.add(new Salary(new BigDecimal(100.2300)));
        
        for(Salary s : salarySet){
            System.out.println(s.toString());
        }
    }
}

 

2. 保證類的自然順序與equals一致。在重寫 compareTo() 方法以定制比較邏輯時，需要確保其與等價性判斷方法 equals() 保持一致，即 e1.equals(e2) 和e1.compareTo(e2)==0 具有相同的值，這樣的話我們就稱自然順序就和 equals 一致。

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

public class PersonWithQQ implements Comparable<PersonWithQQ> {
    
    private int id;
    private int qq;
    
    public PersonWithQQ(int id,int qq){
        this.id = id;
        this.qq = qq;
    }
    
    //與compareTo的方法不一致，也就是與自然順序不一致。
    @Override 
    public boolean equals(Object o){          //......1
        if(!(o instanceof PersonWithQQ)) 
            return false;
        PersonWithQQ person = (PersonWithQQ)o;
        return this.id==person.id;
    }
    
    //compareTo方法得到的順序，稱為自然順序。
    @Override
    public int compareTo(PersonWithQQ obj) {  //......2
        // TODO Auto-generated method stub
        return this.qq-obj.qq;
    }

    public String toString(){
        return id+","+qq;
    }

    public static void main(String[] args) {
        
        TreeSet<PersonWithQQ> personSet = new TreeSet<PersonWithQQ>(); //......3
        
        personSet.add(new PersonWithQQ(101,301)); //...p1
        personSet.add(new PersonWithQQ(101,302)); //...p2 
        personSet.add(new PersonWithQQ(102,302)); //...p3
        
        for(PersonWithQQ p : personSet){
            System.out.println(p.toString());
        }
        
    }
}

可以看到，PersonWithQQ這個類equals比較的是id，而compareTo比較的是qq號碼，違反了e1.equals(e2) 和e1.compareTo(e2)==0 具有相同的布爾值。這樣，沒有顯式比較器的有序集合行為會“奇怪”。請看輸出：

101,301
101,302

 

事實上本來按照equals的方法，p1和p2應該是指同一個的對象，現在卻加入了不能允許有重復值的set集合里面。

對於p2和p3，我們有(!p2.equals(p3) && p2.compareTo(p3) == 0)，p3無法加入到set集合里，set集合里只有兩個對象。這是因為在sorted set的角度，p2和p3是相等的，而卻跟equals的相等方法矛盾。這就是自然順序與equals不一致。

 

上述的Person類，其實也是不嚴謹的，因為沒有覆蓋equals方法來表達判斷對象相等的標准是id相等。

 

雖然是這種情況只發生在沒有顯式比較器有序集合中(sorted set/map)，但是，在實現Comparable接口時，還是建議覆蓋equals方法和hashCode方法，保證與自然順序（CompareTo方法）一致，防止在有序集合中使用出問題。

 

解決方法很簡單，要不就重新覆蓋equals或compareTo的其中一個方法，使其與另一個方法一致。要不就顯式使用比較器。

上述PersonWithQQ類中第33行代碼替換為：

//顯式使用Comparator
        TreeSet<PersonWithQQ> personSet = new TreeSet<PersonWithQQ>(new Comparator<PersonWithQQ>() {

            @Override
            public int compare(PersonWithQQ o1, PersonWithQQ o2) {
                // TODO Auto-generated method stub
                
                return o1.id-o2.id;
            }
            
        });

本質上來說，使用比較器也是為了使自然順序與equals一致，這樣最為穩妥。

 

再來看Comparator<T>

java.util 
Interface Comparator<T>

簡單來說，Comparator是策略模式的一種實現，體現了將類和排序算法相分離的原則。

public class PersonComparator implements Comparator<Person> {

    @Override
    public int compare(Person p0, Person p1) {
        // TODO Auto-generated method stub
        
        return p0.name.compareTo(p1.name);
    }
}

這是Person類的另一種排序方法，根據名字字母排序，因此輸出不再根據id排列：

---------------Result 3----------------
Person: 301 , a
Person: 139 , b
Person: 113 , c
Person: 101 , d
Person: 100 , e
Person: 143 , f

而這個Comparator可以作為參數傳遞給sort方法，提供各種不同的排序方法。

在很多時候，對於需要排序的原始類，例如Person類、PersonWithQQ類，不一定能修改代碼使其實現Comparable接口；這時候Comparator就可以發揮作用了。

 

 

參考：

http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html

http://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html

http://blog.csdn.net/itm_hadf/article/details/7432782