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 不一致的排序。

注意，不重写 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;
    }

    /** 省略 set、get 与 toString() 方法 */
}

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

四、总结

因此一个集合要想实现排序可以用上面两种方法

1：让元素自身具备比较功能，需要实现Comparable接口，覆盖compare()方法

2：让集合自身具备比较功能，定义一个类实现Comparator接口，实现compare 方法将该类的对象返回给集合的构造函数