Java Comparable 和 Comparator 接口详解


本文基于 JDK8 分析


Comparable

Comparable 接口位于 java.lang 包下,Comparable 接口下有一个 compareTo 方法,称为自然比较方法。一个类只要实现了这个接口,意味着该类支持自然排序

所谓自然排序,就是按默认规则组成的排序,例如 1234 就是自然排序,因为 2 就是比 1 大,这是默认规定的。类比到 Comparable,我们在 compareTo 中定义自己需要的默认比较规则,以后如果用到 Collections.sort 和 Arrays.sort 方法排序,或者是作为 SortedSet、SortedMap 等组件的元素,就可以按照我们想要的规则排序了

比较的对象不应该出现 null,因为 null 不属于任何类的实例。如果出现了 e.compareTo(null) 这种情况,应该抛出 NullPointerException


Comparable 的用法

Comparable 接口在 JDK8 中的源码

// T 是可比较的类型
public interface Comparable<T> {
    public int compareTo(T o);
}

需要比较的类只需实现 Comparable 接口即可,在 compareTo 中定义自己的比较规则

  • 返回 0 表示当前对象与目标对象相等
  • 返回正数表示当前对象比目标对象大
  • 返回负数表示当前对象比目标对象小
public class User implements Comparable<User>{
    private Integer id;
    private Integer age;

    // 构造方法和 set/get 方法省略 ...
	
    // 第一种实现方式
    public int compareTo(User o) {
        // 根据用户的年龄比较,参数 o 为目标比较对象
        if(this.age > o.getAge()) {
            // 当前对象比目标对象大,则返回 1
            return 1;
        }else if(this.age < o.getAge()) {
            // 当前对象比目标对象小,则返回 -1
            return -1;
        }else{
            // 若是两个对象相等,则返回 0
            return 0;
        }
    }
    
    // 第二种实现方式
    public int compareTo(User o) {
        return this.age - o.getAge();
    }
}

compareTo 和 equals

强烈建议自然排序和 equals 的顺序保持一致(就是两个对象调用 compareTo 方法和调用 equals 方法返回的布尔值应该一样)

这个建议在需要同时保持元素有序和唯一的集合中尤其重要。例如 TreeSet,它是一个 Set 集合,通过元素的 hashCode() 和 equals() 来判断元素是否唯一,同时还会依据 Comparator 或是 Comparable 接口对元素进行排序。假如出现了 equals 和 compareTo 行为不一致,就会出现十分诡异的情况,JDK 官方文档有对该情况的说明:

如果将两个键 a 和 b 添加到没有使用显式比较器的有序集合中,使得 (!a.equals(b) && a.compareTo(b) == 0) 成立,那么第二个 add 操作(添加 b)将返回 false(有序集合的大小没有增加),因为从有序集合的角度来看,a 和 b 是相等的

明明 equals 已经判断该元素不重复,但还是拒绝了添加操作,因为 compaTo 认为这两个元素是相等的,这明显不是我们想要的结果。正确的分工是,equals 负责判断元素唯一性,compareTo 负责元素的排序,两者互不干扰

下面以 TreeSet 为例,TreeSet 的 add 方法基于 TreeMap 的 put 方法实现,TreeMap 的结构是一颗红黑树,会根据默认比较器一直向下迭代,直到某个节点的左子树或右子树为 null,并将元素插入到该节点的左子树或右子树,并对整棵树重写进行颜色绘制。如果发现树中某个节点的值和待插入元素元素一致,则覆盖并返回旧值。回到 TreeSet 的 add 方法,put 方法的返回值不为 null,自然 add 方法的返回值就是 false

// TreeSet 中的 add 方法,基于 TreeMap 的 put 方法实现
public boolean add(E e) {
    return m.put(e, PRESENT) == null;
}

// TreeMap 中的 put 方法,这里我们只关注被注释的那一段代码即可
public V put(K key, V value) {
    Entry<K,V> t = root;
    if (t == null) {
        compare(key, key); 
        root = new Entry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
    int cmp;
    Entry<K,V> parent;
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {
        do {
            parent = t;
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
    // 这里使用 compareTo 对元素作自然排序
    else {
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
        Comparable<? super K> k = (Comparable<? super K>) key;
        do {
            parent = t;
            cmp = k.compareTo(t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                // 就是在这里遇到相等的元素(根据比较器比较)
                return t.setValue(value);
        } while (t != null);
    }
    Entry<K,V> e = new Entry<>(key, value, parent);
    if (cmp < 0)
        parent.left = e;
    else
        parent.right = e;
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}

Comparator

Comparator 位于 java.util 包下,也是用来排序的。与 Comparable 不同的是,Comparable 表示该类“可以支持排序”,自身提供了排序方法;而 Comparator 则是一个“比较器”,这个比较器需要实现 Comparator 接口,可以通过这个比较器来对类排序,类本身不需要任何操作

当需要作排序操作如 Collections.sort 或是 Arrays.sort 时,把比较器作为参数传进去即可。也可以使用 Comparator 来控制某些集合(TreeSet 或 TreeMap),如果集合要被序列化,Comparator 比较器也必须实现序列化接口

所以说,Comparator 和 Comparable 本质上没有什么区别,Comparable 要注意的点在 Comparator 中亦是如此


Comparator 的使用

自定义一个 User 实体类

public class User {
    private Integer id;
    private Integer age;

    // 构造方法和 set/get 方法省略 ...
}

自定义比较器

class AgeComparator implements Comparator<User> {
    
    @Override
    public int compare(User u1, User u2) {
        if (u1.getAge() > u2.getAge()) {
            return 1;
        } else if (u1.getAge() < u2.getAge()) {
            return -1;
        } else {
            return 0;
        }
    }
}

要使用比较器,只需要直接创建即可。也可以使用匿名内部类或者 lambda 表达式

// 已经定义了比较器,可直接使用
Collections.sort(list, new AgeComparator());
// 使用匿名内部类
Collections.sort(list, new Comparator<User>() {
    @Override
    public int compare(User u1, User u2) {
        ...
    }
});
// 使用 lambda 表达式
Collections.sort(list, (u1, u2) -> {...});

Comparator 中常用的默认方法

相比于 Comparable,Comparator 提供了更多默认方法和静态方法,功能更加强大

  • reversed

    返回一个比较器,是原比较器的逆序(没有实现则是自然排序),底层使用 Collections 的 reverseOrder 方法实现

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

    返回一个比较器,比较规则由传入的参数制定,该方法有两个重载方法

    // 参数为要比较的元素类型,默认按自然排序比较
    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor)
    // 第一个参数为要比较的元素类型,第二个参数为比较规则
    public static <T, U> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)
    

    具体用法如下:

    Collections.sort(list, Comparator.comparing(User::getAge));
    Collections.sort(list, Comparator.comparing(Student::getLikeGame, Comparator.reverseOrder()));
    
  • thenComparing

    多条件排序的方法,当我们排序的条件不止一个的时候可以使用该方法。比如说我们对 User 先按照 age 字段排序,再按照 id 排序,就可以使用 thenComparing 方法

    Collections.sort(list, comparator.thenComparing(x -> x.getId()));
    

    thenComparing 有很多重载方法,功能都一样的,但有一点要注意:传进去的类型都是按照自然排序,id 是一个整数,规则就是 1234 从小到大排序。如果你传进去的是一个对象,而你希望能自定义比较规则,那么这个对象必须实现 Comparable 接口

  • nullsFirst 和 nullsLast

    这两个方法的意思是,如果排序的字段为 null 的情况下,这条记录该如何处理。nullsFirst 是将这条记录排在最前面,而 nullsLast 是将这条记录排序在最后面。如果多个 key 都为 null 的话,将无法保证这几个对象的排序

    Comparator<User> comparator = Comparator.comparing(User::getAge, Comparator.nullsLast(Comparator.reverseOrder()));
    
  • reverseOrder 和 naturalOrder

    返回自然排序的比较器,reverseOrder 则是逆序。同样的,对于自然排序,如果希望自定义规则,必须实现 Comparable 接口

    Collections.sort(list, Comparator.reverseOrder());
    

你可能感兴趣的:(Java,基础,java)