Comparator 与 Comparable

Comparable :
    该接口强调对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射(如 TreeMap)中的键或有序集合(如 TreeSet)中的元素，无需指定比较器。

该接口只有一个方法：

int compareTo(T o)
        比较此对象与指定对象的顺序。

    int compareTo(T o) ：如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。 注意：此类具有与 equals 不一致的自然排序。

Comparator:
    强调对某个对象 collection 进行整体排序 的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection(List等) 提供排序。

该接口只有两个个方法：

int compare(T o1, T o2)
        比较用来排序的两个参数。
boolean equals(Object obj)
        指示某个其他对象是否“等于”此 Comparator。

    int compare(T o1, T o2)： 比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。注意：此 Comparator 强行进行与 equals 不一致的排序。
    boolean equals(Object obj)：指示某个其他对象是否“等于”此 Comparator。此方法必须遵守 Object.equals(Object) 的常规协定。此外，仅当 指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时，此方法才返回 true。注意，不 重写 Object.equals(Object) 方法总是 安全的[因为任何类，默认都是已经继承了Object 超类，在Object 已经实现了该方法]。然而，在某些情况下，重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序，从而提高性能。

下面就来做一个例子通过上面两个接口的实现对一个集合内对象的num 进行升序排列输出，当num 相同时则按照type 的字典序进行排序。

Comparable 实现：

import java.util.*;public class ComparableTest {    public static void main(String[] args) {        List<Fruit> list = new ArrayList<>();        list.add(new Fruit("Apple",10));        list.add(new Fruit("Orange",8));        list.add(new Fruit("Banana",15));        list.add(new Fruit("Strawberry ",7));        list.add(new Fruit("Pear",7));        Collections.sort(list);     //如果是set 的集合或者 Map,不用指定Collections.sort() 排序        Iterator<Fruit> iterator = list.iterator();        System.out.println("排序后........");        while (iterator.hasNext()){            System.out.println(iterator.next());        }    }}class Fruit implements Comparable<Fruit>{    private String type;    private int num;    public Fruit(String type , int num){        this.type = type;        this.num = num;    }    @Override    public int compareTo(Fruit fruit) {        int tmp = this.num - fruit.num;        return tmp != 0 ? tmp : this.type.compareTo(fruit.type);    }    @Override    public String toString() {        return type + ":"  + num;    }}

输出
排序后……..
Pear:7
Strawberry :7
Orange:8
Apple:10
Banana:15

Comparator实现：

import java.util.*;public class ComparatorTest {    public static void main(String[] args) {        List<Animal> list = new ArrayList<>();        list.add(new Animal("Dog",10));        list.add(new Animal("Cat",8));        list.add(new Animal("Tiger",15));        list.add(new Animal("Panda ",7));        list.add(new Animal("Lion",7));        Collections.sort(list,new Sort());        Iterator<Animal> iterator = list.iterator();        System.out.println("排序后........");        while (iterator.hasNext()){            System.out.println(iterator.next());        }    }}class Sort implements Comparator<Animal>{    @Override    public int compare(Animal animal1, Animal animal2) {        int tmp1 = animal1.getNum() - animal2.getNum();        int tmp2 = animal1.getType().compareTo(animal2.getType());        return tmp1 != 0 ? tmp1 : tmp2;    }}class Animal{    private String type;    private int num;    Animal(String type , int num){        this.type = type;        this.num = num;    }    public int getNum() {        return num;    }    public String getType() {        return type;    }    public void setType(String type) {        this.type = type;    }    public void setNum(int num) {        this.num = num;    }    @Override    public String toString() {        return type + ":"  + num;    }}

输出
排序后……..
Lion:7
Panda :7
Cat:8
Dog:10
Tiger:15

---

因此一个集合要想实现排序可以用上面两种方法：
    一：让元素自身具备比较功能，需要实现Comparable接口，覆盖compare()方法
    二：让集合自身具备比较功能，定义一个类实现Comparator接口，实现compare 方法将该类的对象返回给集合的构造函数