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