小白养成记——Java比较器Comparable和Comparator

一、使用情景

1.  调用Arrays.sort()方法或Collections.sort()方法对自定义类的对象排序

以Arrays.sort()为例。假定有如下自定义的Person类

public class Person {

    private String name;
    private Integer age;

    public Person() {}

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    //Getter and Setter

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (!Objects.equals(name, person.name)) return false;
        return Objects.equals(age, person.age);

    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (age != null ? age.hashCode() : 0);
        return result;
    }
}

创建一个一维数组来存放多个Person对象，然后将该数组作为参数调用数组工具类Arrays的静态方法sort(Object[] a)，最后遍历

@Test
public void test3() {
    Person[] persons = new Person[]{
            new Person("Mike", 23),
            new Person("Alice", 19),
            new Person("Jerry", 17)
    };
    Arrays.sort(persons);
    for (Person person : persons) {
        System.out.println(person);
    }
}

则会出现java.lang.ClassCastException异常，提示Person不能转换为Comparable，这便需要用到比较器。

2. 在TreeSet容器容器中添加自定义类的对象

还是以上文中的Person类为例。创建一个TreeSet容器，将多个Person对象添加其中，查看是否添加成功

@Test
public void test4() {
    Set setOfPersons = new TreeSet();
    setOfPersons.add(new Person("Mike", 23));
    setOfPersons.add(new Person("Alice", 19));
    setOfPersons.add(new Person("Jerry", 17));
    System.out.println("setOfPersons.size() = " + setOfPersons.size());
}

可以看到还是会出现java.lang.ClassCastException异常，提示Person不能转换为Comparable。

二、使用方式

1. 自然排序——使用java.lang.Comparable<T>接口

在自定义类时可以让其实现这个Comparable接口，重写接口中的int compareTo(T o)方法，这样该类便“具有了比较的功能”。如创建一个实现了Comparable接口的Person类

public class Person implements Comparable<Person> {

    private String name;
    private Integer age;

    public Person() {}

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (!Objects.equals(name, person.name)) return false;
        return Objects.equals(age, person.age);

    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (age != null ? age.hashCode() : 0);
        return result;
    }

    /**
     * 在这里定义比较的方式，如先比较年龄，若年龄相同则再比较姓名
     * 按照升序排序的规则为:
     *      若当前对象的指定属性大于传入的待比较对象的指定属性，则返回一个正整数(如1)
     *      若当前对象的指定属性小于传入的待比较对象的指定属性，则返回一个负整数(如-1)
     *      若当前对象的指定属性等于传入的待比较对象的指定属性，则返回0
     * @param anotherPerson 传入的待比较对象
     * @return 返回一个整数作为比较结果的参考
     */
    @Override
    public int compareTo(Person anotherPerson) {
        
        int differ = this.getAge() - anotherPerson.getAge();
        if (differ != 0) {
            return differ / Math.abs(differ);
        }
        return this.getName().compareTo(anotherPerson.getName());
    }
}

这样的Person类便具有了“比较”的功能，在调用sort()方法或添加到TreeSet容器中时便不会再出现异常，无需再更改代码。显然，最值得关注的地方就是compareTo(T o)方法的实现。由于String以及基本数据类型的包装类都已经实现了带泛型的Comparable接口，类的属性一般来说也都是这些类型，所以在写compareTo(T o)方法的方法体时可以直接调用属性的compareTo(T o)方法，省去条件分支语句。

2. 定制排序——使用java.util.Comparator<T>接口

如果需要让Person类的对象在不同情景下使用不同的排序方式，那么通过让Person类实现Comparable接口的方式便显得不具有灵活性了，此时便可以使用Comparator接口。

Comparator接口的使用与Comparable有所不同，它并不是要让自定义的类来实现，而是在需要排序的地方临时创建一个Comparator的实现类，并实现其中的int compare(T o1, T o2)方法，对传入的对象实现排序(比较)。由于这个实现类只是“临时”的，所以使用一个匿名类即可。

数组工具类Arrays的sort()方法是重载的，除了sort(Object[] a)外还有一个sort(T[] a, Comparator<? super T> c)，使用后者，传入一个Comparator接口的匿名实现类便可以实现定制排序，如

@Test
public void test3() {
    Person[] persons = new Person[]{
            new Person("Mike", 23),
            new Person("Alice", 19),
            new Person("Jerry", 17)
    };
    Arrays.sort(persons, new Comparator<Person>() {
        @Override
        public int compare(Person person1, Person person2) {
            int differ = person1.getName().compareTo(person2.getName());
            if (differ != 0) {
                return differ;
            }
            return person1.getAge().compareTo(person2.getAge());
        }
    });
    for (Person person : persons) {
        System.out.println(person);
    }
}

这样便会按照匿名类里的compare(T o1, T o2)方法指定的方式来进行排序，无论Person类是否实现了Comparable接口。

对TreeSet的处理类似。可以在创建TreeSet容器时调用其含参的构造器，传入一个Comparator接口的匿名实现类,如

@Test
public void test4() {
    Set setOfPersons = new TreeSet(new Comparator<Person>() {
        @Override
        public int compare(Person person1, Person person2) {
            int differ = person1.getName().compareTo(person2.getName());
            if (differ != 0) {
                return differ;
            }
            return person1.getAge().compareTo(person2.getAge());
        }
    });
    setOfPersons.add(new Person("Mike", 23));
    setOfPersons.add(new Person("Alice", 19));
    setOfPersons.add(new Person("Jerry", 17));
    System.out.println("setOfPersons.size() = " + setOfPersons.size());
}

三、二者的区分

由于这两个接口名以及其中的方法名都含有compare前缀，因此初次接触很容易混淆。二者的区别有如下几点

1）接口Comparable<T>位于java.lang包下，而接口Comparator<T>位于java.util包下。

2）Comparable<T>接口可以让自定义类来实现，从而使该的类具有“顺序性”；而Comparator<T>接口并不是让自定义类来实现的，只需要在需要用到排序的地方临时创建一个指定泛型的实现类，对指定类型的对象进行排序。

3）Comparable<T>接口的compareTo(T o)方法中含有一个形参,自定义类的对象可以调用；而Comparator<T>接口的compare(T o1, T o2)方法中含有两个形参，一般来说不需要手动调用。

4）定制排序优先。