目录

Comparable接口

Comparable小结

Comparator接口

Comparator小结

Comparable和Comparator区别

---

        本文基于JDK1.8源码。

Comparable<T>接口

        将Comparable<T>源码中的所有注释去掉后，代码如下：

package java.lang;
import java.util.*;

public interface Comparable<T> {
    public int compareTo(T o);
}

从上面源码可以看到

（1）Comparable是一个泛型接口，泛型是T。

（2）接口中只有一个compareTo方法，返回值为int，它用于比较两个对象的“大小”，如果当前对象小于比较的对象o，返回一个负整数；如果等于比较的对象o，返回0，如果大于比较的对象o，返回一个正整数；

（3）如果compareTo方法中的o对象为null，方法会抛出NullPointerException；

关于compareTo方法实现时，需要注意一下几点：

（1）compareTo方法的实现必须保证sgn(x.compareTo(y))=-sgn(y.compareTo(x))，也就是符号相反，比如说x.compareTo(y)返回值为9，sgn(9)=1，那么y.compareTo(x)返回的一定是一个小于0的整数，比如-7，sgn(-7)=-1。如果前者抛出异常，后者也必须抛出异常；

（2）必须保证序的传递性，也就是说如果x.compareTo(y)>0，并且y.compareTo(z)>0，必然会有x.compareTo(z)>0;

（3）如果x.compareTo(y)==0，则sgn(x.compareTo(z)) == sgn(y.compareTo(z))

（4）一般推荐compareTo方法实现时和equals方法联系起来，满足(x.compareTo(y)==0) == (x.equals(y))，也就是说x.compareTo(y)==0和x.equals(y)有相同的boolean值，也就是说两者要么全部为false，要么全部为true。

下面举个例子说明：

package main.compare;

/**
 * Created by leboop on 2018/11/18.
 */
public class Person implements Comparable<Person> {
    private String name;
    private Integer age;

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

    @Override
    public int compareTo(Person person) {

        return this.age - person.age;
    }

}

代码中Person类实现了Comparable接口，它是Comparable接口的实现类，按照属性age定义了Person类对象之间的一种“序”。但Person类并未对equals方法进行重写，直接继承了父类Object的equals方法。我们来测试一下：

package main.compare;


import java.util.*;

/**
 * Created by leboop on 2018/11/18.
 */
public class CompareTest {
    public static void main(String[] args) {
        Person p1 = new Person("zhangsan", 10);
        Person p2 = new Person("lisi", 10);
        Person p3 = new Person("wangwu", 10);
        SortedSet<Person> sortedSet=new TreeSet();
        boolean flag1=sortedSet.add(p1);
        boolean flag2=sortedSet.add(p2);
        boolean flag3=sortedSet.add(p3);
        System.out.println("flag1:"+flag1);
        System.out.println("flag2:"+flag2);
        System.out.println("flag3:"+flag3);
        System.out.println(sortedSet);

    }
}

程序运行结果如下：

flag1:true
flag2:false
flag3:false
集合大小：1

测试类中定义了三个Person对象p1、p2和p3，根据equals方法，它们是三个不同的对象，但从上面定义的“序”的角度来看，三个对象大小是一样的（age都是10），当我们将他们加入到一个有序集合中，p2和p3会加入失败，这会产生一些意想不到的结果，所以推荐在实现compareTo方法时，应当与equals方法保持一致。

如果将上面的三个Person对象改为：

Person p1 = new Person("zhangsan", 20);
Person p2 = new Person("lisi", 30);
Person p3 = new Person("wangwu", 10);

那么最终的输出结果会是三个排序好的对象。

        事实上，在JDK中实现了Comparable的绝大部分Java核心类中的自然顺序都与equals方法是一致的，当然也有特例，比如java.math.BigDecimal。

package main.compare;


import java.math.BigDecimal;
import java.util.*;

/**
 * Created by leboop on 2018/11/18.
 */
public class CompareTest {
    public static void main(String[] args) {
        BigDecimal d1=new BigDecimal("1.0");
        BigDecimal d2=new BigDecimal("1.00");
        System.out.println("d1的精度："+d1.scale());
        System.out.println("d2的精度："+d2.scale());
        System.out.println("d1.equals(d2)："+d1.equals(d2));
        System.out.println("d1.compareTo(d2)："+d1.compareTo(d2));
    }
}

程序运行结果：

d1的精度：1
d2的精度：2
d1.equals(d2)：false
d1.compareTo(d2)：0

Process finished with exit code 0

程序中定义了两个不同精度的BigDecimal对象d1和d2，对于BigDecimal类，equals会比较对象的值和精度，因为两者精度不同，所以d1.equals(d2)返回false，而compareTo仅仅比较值的大小，d1和d2的大小都是0，所以d1.compareTo(d2)返回0。

按照如下compareTo和equals方法实现就比较合理了：

/**
 * Created by leboop on 2018/11/18.
 */
public class Person implements Comparable<Person> {
    private String name;
    private Integer age;

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

    @Override
    public int compareTo(Person person) {
        if (this.name.equals(person.name)){
            return this.age - person.age;
        }else {
            return this.name.compareTo(person.name);
        }
    }

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

        Person person = (Person) o;

        if (name != null ? !name.equals(person.name) : person.name != null) return false;
        return age != null ? age.equals(person.age) : person.age == null;
    }

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

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

 测试类如下：

import java.util.SortedSet;
import java.util.TreeSet;

/**
 * Created by leboop on 2020/5/23.
 */
public class MainTest {
    public static void main(String[] args) {
        Person p1=new Person("zs",20);
        Person p2=new Person("zs",30);
        Person p3=new Person("ls",20);
        Person p4=new Person("zs",20);
        SortedSet<Person> sortedSet=new TreeSet<>();
        sortedSet.add(p1);
        sortedSet.add(p2);
        sortedSet.add(p3);
        sortedSet.add(p4);
        for(Person p:sortedSet){
            System.out.println(p);
        }
    }
}

 输出结果：

Person{name='ls', age=20}
Person{name='zs', age=20}
Person{name='zs', age=30}

符合预期。

 

Comparable<T>小结

（1）可以将Comparable<T>接口看成拥有一种可以给实现类某种“序”的神力，谁实现类该接口就具备了一种“序”，而每个实现类可以拥有不同的“序”；

（2）compareTo方法实现时需要与equals方法保持一致，如果不一致必须写明。

 

Comparator<T>接口

        Comparator接口的源码去掉注释后，如下：

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;

@FunctionalInterface
public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);

    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    default Comparator<T> thenComparing(Comparator<? super T> other) {
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

    default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }

    default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }

    default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
        return thenComparing(comparingInt(keyExtractor));
    }

    default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
        return thenComparing(comparingLong(keyExtractor));
    }

    default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        return thenComparing(comparingDouble(keyExtractor));
    }

    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }

    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }

    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }

    public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(false, comparator);
    }

    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }

    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }

    public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
    }

    public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
    }
}

从上面源码可以看到

（1）Comparator<T>也是一个泛型接口，T是泛型；

（2）接口内部包含很多方法，我们只关注int compare(T o1, T o2)方法。

（3）compare方法中的两个参数有一个是null值都会抛出空指针异常；

现在如果也想实现Person类可以按照age可以排序，Person类就不需要直接实现Comparator接口了，做法是单独为Person类提供一个比较器，这个比较器需要实现Comparator接口，具体如下：

package main.compare;

/**
 * Created by leboop on 2018/11/18.
 */
public class Person {
    private String name;
    private Integer age;

    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 +
                '}';
    }
}

单独定义一个Person类的降序比较器，如下：

package main.compare;

import java.util.Comparator;

/**
 * Created by leboop on 2018/11/18.
 */
public class DesComparator implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        return o2.getAge()-o1.getAge();
    }
}

测试类如下：

package main.compare;


import java.math.BigDecimal;
import java.util.*;

/**
 * Created by leboop on 2018/11/18.
 */
public class CompareTest {
    public static void main(String[] args) {
        Person p1=new Person("zhangsan",10);
        Person p2=new Person("lisi",29);
        Person p3=new Person("wangwu",25);
        Person p4=new Person("mazi",34);
        List<Person> personList=new ArrayList<>();
        personList.add(p1);
        personList.add(p2);
        personList.add(p3);
        personList.add(p4);
        System.out.println("排序前："+personList);
        Collections.sort(personList,new DesComparator());
        System.out.println("排序后："+personList);
    }
}

运行结果如下：

排序前：[Person{name='zhangsan', age=10}, Person{name='lisi', age=29}, Person{name='wangwu', age=25}, Person{name='mazi', age=34}]
排序后：[Person{name='mazi', age=34}, Person{name='lisi', age=29}, Person{name='wangwu', age=25}, Person{name='zhangsan', age=10}]

Process finished with exit code 0

对Comparator的compare方法实现有如下几点要求：

（1）保证sgn(compare(x, y)) 和 -sgn(compare(y, x))相等，compare(x, y)抛出异常当且仅当compare(y, x)也抛出异常；

（2）保证关系传递性，也就是compare(x, y)>0，并且compare(y, z)>0，则compare(x, z)>0；

（3）如果compare(x, y)==0，则sgn(compare(x, z))==sgn(compare(y, z))；

（4）一般推荐实现时，和equals方法相关联，保证compare(x, y)==0 和x.equals(y)要么同时返回false，要么同时返回true

 

Comparator小结

（1）Comparator可以看成一个比较器接口，它不能赋予给像Person这样的类比较能力，只能创建一个比较器类，而Person类可以使用这个比较器；

 

Comparable和Comparator比较

（1）Comparable接口可以直接赋予实现类一种“序”的能力，而Comparator不能直接赋予这种能力，它通过创建一个“序”给Person用，打个比方，将Comparable和Comparator看成是具备法力的两位神仙，Comparable可以直接给你一种“序”的能力，此时你直接拥有了“序”的能力，而Comparator不能直接给你这种“序”的能力，但是它可以变出一个“序”的法力棒，你去使用法力棒来实现“序”的能力，当法力棒丢失了，你也就没有“序”的能力了；

（2）Comparable的compareTo方法和Comparator的compare方法实现原则基本相同；