Comparable 与 Comparator

1.背景

最近一些业务需求总是遇到用List<对象>的比较，下面介绍下用到的排序的两种方法Comparable 与 Comparator。

2.定义

Comparable和Comparator都是用来实现集合中元素的比较、排序的。
Comparable是在集合内部定义的方法实现的排序，位于java.lang下。
Comparator是在集合外部实现的排序，位于java.util下。

2.1.Comparable

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：

1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数
2、比较者等于被比较者，那么返回0
3、比较者小于被比较者，那么返回负整数

2.2.Comparator

Comparator可以认为是是一个外比较器，个人认为有两种情况可以使用实现Comparator接口的方式：
1、一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较

2、一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

1、o1大于o2，返回正整数
2、o1等于o2，返回0
3、o1小于o2，返回负整数

3.示例

3.1.Comparable

Comparable会对实现它的每个类的对象进行整体排序。这个接口需要类本身去实现。若一个类实现了Comparable 接口，实现 Comparable 接口的类的对象的 List 列表 ( 或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。此外，实现 Comparable 接口的类的对象 可以用作 “有序映射 ( 如 TreeMap)” 中的键或 “有序集合 (TreeSet)” 中的元素，而不需要指定比较器。

定义实现User类，实现Comparable

package com.test.one;

/**
 * 描述：
 * 作者：袁伟倩
 * 创建日期：2017-10-14 16:04.
 */

public class User implements Comparable<User> {

    // 年龄
    private int age;
    // 姓名
    private String name;

    // 创建有参构造方法
    public User(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // get/set方法
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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


    // 生成tostring方法
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    // 重写comparable的方法
    @Override
    public int compareTo(User o) {
        int i = this.age-o.age;
        return i;
    }
}

定义Test类，运行效果

package com.test.one;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 描述：
 * 作者：袁伟倩
 * 创建日期：2017-10-14 15:36.
 */

public class Test {

    public static void main(String[] args) {

        User user1 = new User("张三",18);
        User user2 = new User("李四",17);
        User user3 = new User("赵五",19);

        List<User> list = new ArrayList<User>();

        list.add(user1);
        list.add(user2);
        list.add(user3);

        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }

}

运行结果

[User{age=18, name='张三'}, User{age=17, name='李四'}, User{age=19, name='赵五'}]
[User{age=17, name='李四'}, User{age=18, name='张三'}, User{age=19, name='赵五'}]

分析运行效果

一开始创建对象user1，对象实例o 是张三，当运行到user2时，this就是对象user2,此时会进行排序，这个时候返回到i是 -1，即对象user2中到age比对象user1到小。

继续运行程序

当前运行到this对象是user3，对象o是上一步到对象user2，此时i返回为2，即age在对象user2比对象user3小；

之后在运行 Collections.sort(list); 其底层是

  default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

Arrays.sort是正序。所以最终结果是递增的。

总结：User类实现了Comparable接口中的compareTo方法。实现Comparable接口必须修改自身的类，即在自身类中实现接口中相应的方法。

3.2.Comparator

上面介绍了通过类实现Comparable接口，可以实现排序，那么对于这个类已经固定，无法进行对其类自身的修改，也修饰词final了，你也别想继承再implements Comparable，那么此时怎么办呢？在类的外部使用Comparator的接口。

对象类

package com.test.one;

/**
 * 描述：
 * 作者：袁伟倩
 * 创建日期：2017-10-14 17:11.
 */

public class Person {
    // 年龄
    private int age;
    // 姓名
    private String name;

    // 创建有参构造方法
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // get/set方法
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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


    // 生成tostring方法
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

}

实现

package com.test.one;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 描述：
 * 作者：袁伟倩
 * 创建日期：2017-10-14 17:12.
 */

public class TestPerson {
    public static void main(String[] args) {

        Person user1 = new Person("张三",18);
        Person user2 = new Person("李四",17);
        Person user3 = new Person("赵五",19);

        List<Person> list = new ArrayList<Person>();

        list.add(user1);
        list.add(user2);
        list.add(user3);

        System.out.println(list);
        Collections.sort(list,new Comparator<Person>(){

            @Override
            public int compare(Person o1, Person o2)
            {
                if(o1 == null || o2 == null) return 0;

                return o1.getAge()-o2.getAge();
            }

        });
        System.out.println(list);
    }
}

这里（public static void sort(List list, Comparator<? super T> c) ）采用了内部类的实现方式，实现compare方法，对类Person的list进行排序。

4.综述

Comparable 是排序接口；若一个类实现了 Comparable 接口，就意味着 “该类支持排序”。而 Comparator 是比较器；我们若需要控制某个类的次序，可以建立一个 “该类的比较器” 来进行排序。
  前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。可以说前者属于 “静态绑定”，而后者可以 “动态绑定”。

5、java8以上的Lambda比较器

在java8以上版本，List接口直接提供了排序方法， 所以不需要使用Collections.sort。

//循环
listDevs.forEach((developer)->System.out.println(developer));
//排序
listDevs.sort((Developer o1, Developer o2)->o1.getAge()-o2.getAge());
//根据名字排序
listDevs.sort((o1, o2)->o1.getName().compareTo(o2.getName()));
//从小到大
Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
    listDevs.sort(salaryComparator);
//从大到小 
Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
listDevs.sort(salaryComparator.reversed());