Comparator and Comparable及Collections and Collection的用法和區別

　　此篇博客整理自網絡

　　

　　Collections and Collection

　　Collection是一個集合接口，Collections是一個包裝類（或幫助類），這是二者最明顯的區別。Collections提供了一 些static方法來對 Collection對象進行處理，比如：對Collection對象的復制、添加元素、修改元素、對元素進行排序、交換倆個元素的位置、取 Collection的子集等等操作。另外Collection是j2sdk中集合框架的根接口，所有的其他特殊類型的結合接口或者類都直接或間接的實現 了這個接口。

　　java.util.Collections   API >>

---

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
    boolean equals(Object o);
    int hashCode();
}

 

　　java.util.Collections API >>

---

public class Collections {
  //注意Collections只是Collection集合接口的一個幫助類，並沒有implements Collection  
  ... ...  
}

 

　　Comparator and Comparable　

　　Comparator和Comparable都是接口，倆者之間可以說沒什么關系。Comarator位於包java.util下，而Comparable位於包 java.lang下。通俗的說：Comparator是一個比較器，相當於一種工具，它定義了倆個方法，分別是 int compare(T o1, T o2)和 boolean (Object obj)，所以你可以通過實現這個接口來定義你所有需要的比較器，如比較倆個人的大小，對象人有姓名、性別、年齡等屬性，你在定義這個比較器的時候就可以在compare方法中對傳入的倆個參數（person1，person2）的年齡進行大小的比較，從而確定這倆個人的大小。
　　Comparable接口是你要是定義的類要實現的一個接口（如果這個類的實例需要和同一類的別的實例比較大小，而這個大小關系你希望是你自己定義的），它只提供了 int compareTo(T o)方法，也就是說假如我定義了一個Person類，這個類實現了 Comparable接口，那么當我實例化Person類的person1后，我想比較person1和一個現有的Person對象person2的大小時，我就可以這樣來調用：person1.comparTo(person2),通過返回值就可以判斷了；而此時如果你定義了一個 PersonComparator（實現了Comparator接口）的話，那你就可以這樣：PersonComparator comparator= new PersonComparator();comparator.compare(person1,person2);。

　　java.lang.Comparable API >>

---

public interface Comparable<T> {
    public int compareTo(T o);
}

　 此接口強行對實現它的每個類的對象進行整體排序。此排序被稱為該類的自然排序，類的 compareTo 方法被稱為它的自然比較方法。
　　實現此接口的對象列表（和數組）可以通過 Collections.sort（和 Arrays.sort）進行自動排序。實現此接口的對象可以用作有序映射表中的鍵或有序集
合中的元素，無需指定比較器。

　java.util.Comparator API >>

---

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

 　　比較函數強行對某些對象 collection 進行整體排序。可以將 Comparator 傳遞給 sort 方法（如 Collections.sort），從而允許在排序順序上實現精確控制。還可以使用 Comparator 來控制某些數據結構（如 TreeSet 或 TreeMap）的順序。

 

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

　　Comparator和Comparable的區別如下：

Comparable用在對象本身，說明這個對象是可以被比較的，也就是說可以被排序的。（String和Integer之所以可以比較大小，是因為它們都實現了Comparable接口，並實現了compareTo()方法）。

Comparator用在對象外面，相當於定義了一套排序算法來排序。

　　
　　　java.lang.String  API >>

---

 

public final class String implements java.io.Serializable, Comparable<String>, CharSequence{
　　　　... ...
　　　　//String和Integer之所以可以比較大小，是因為它們都實現了Comparable接口，並實現了compareTo()方法
    public int compareTo(String anotherString) {
    int len1 = count;
    int len2 = anotherString.count;
    int n = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;
    int i = offset;
    int j = anotherString.offset;

    if (i == j) {
        int k = i;
        int lim = n + i;
        while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
        }
    } else {
        while (n-- != 0) {
        char c1 = v1[i++];
        char c2 = v2[j++];
        if (c1 != c2) {
            return c1 - c2;
        }
        }
    }
    return len1 - len2;
    }
}

 

　　下面通過具體的例子來理解Comparator和Comparable的區別：

　　 Comparator實例如下：

 

class Name implements Comparable<Name>{  
    public String firstName,lastName;  
    public Name(String firstName,String lastName){  
        this.firstName=firstName;  
        this.lastName=lastName;  
    }  
    //實現接口 
    public int compareTo(Name o) {           
        int lastCmp=lastName.compareTo(o.lastName);  
        return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));  
    }    
    //便於輸出測試  
    public String toString(){                
        return firstName+" "+lastName;  
    }  
} 

 

public class NameSort {  
     public static void main(String[] args) {  
         Name nameArray[] = {  
            new Name("John", "Lennon"),  
            new Name("Karl", "Marx"),  
            new Name("Groucho", "Marx"),  
            new Name("Oscar", "Grouch")  
        }; 
        Arrays.sort(nameArray);  
        System.out.println(Arrays.toString(nameArray));;  
    }  
} 

　　運行結果：[Oscar Grouch, John Lennon, Groucho Marx, Karl Marx]
　　Comparable實例如下：

 

public  class  User implements  Comparable<Object> {  
    private  String id;  
    private  int  age;  
  
    public  User(String id, int  age) {  
        this .id = id;  
        this .age = age;  
    }  
  
    public  int  getAge() {  
        return  age;  
    }  
    public  void  setAge(int  age) {  
        this .age = age;  
    }  
    public  String getId() {  
        return  id;  
    }  
    public  void  setId(String id) {  
        this .id = id;  
    }  
    
    public int compareTo(Object o) {
        return this.age-((User)o).getAge();
    }
  
    /**  
     * 測試方法  
     */   
    public static void main(String[] args){  
        User[] users = new User[]{new User("a", 30),new User("b", 20 )};  
        Arrays.sort(users);  
        for  (int  i = 0 ; i < users.length; i++) {  
            User user = users[i];  
            System.out.println(user.getId() + " "  + user.getAge());  
        }  
    }  
}

 

　　運行結果：b 20
　　　　　　　a 30