Java比较器：Comparable和Comparator

最新推荐文章于 2023-06-18 17:56:42 发布

ProgrammingWay

最新推荐文章于 2023-06-18 17:56:42 发布

阅读量395

点赞数

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： java比较器

本文链接：https://blog.youkuaiyun.com/ProgrammingWay/article/details/104020832

Java 专栏收录该内容

11 篇文章

订阅专栏

本文深入解析Java中的Comparable和Comparator接口，阐述它们在对象排序中的作用和实现方式，以及两者之间的区别和应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、是什么

Comparable和Comparator都只是一个普通的接口。他们是Java用来定义如何比较两个对象大小的规范，真正的比较逻辑需要由实现类来重写其中的比较方法。

2、为什么

在Java中，两个数值类型的变量可以使用比较运算符（">","<"等）直接比较两个数值的大小，但是对于引用类型的数据，则不能直接通过比较运算符（">","<"等）来比较两个对象的大小。所以，Java另外提供了两种用来比较两个对象大小的方式：Comparable和Comparator。

3、怎么用

（1）Comparable（自然排序）

java.lang.Comparable 需要子类来实现该接口，并重写当中的compareTo(Object obj)方法，一旦定义完成后就可以在任何地方对该类的对象进行比较排序（可以认为是在对象内部排序）。

直接看Comparable的源码，里面只定义了一个抽象方法 compareTo(Object obj)。

package java.lang;

public interface Comparable<T> {

    int compareTo(T var1);
}

对于任何一个类，只要实现了 java.lang.Comparable 中的compareTo() 方法，该类的对象就可以使用定义的方式进行比较。Java中的包装类和String类都实现了该接口。下面以 java.lang.String 类为例：

@Test
public void test01() {
    List<String> list = Arrays.asList("FF", "AA", "BB", "DD", "TT");
    System.out.println("before:" + list);
    //实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或 Arrays.sort进行自动排序。
    //实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
    Collections.sort(list);
    System.out.println("after:" + list);
}

输出结果：
before:[FF, AA, BB, DD, TT]
after:[AA, BB, DD, FF, TT]

查看String源码可以看到，String类实现了Comparable接口，并且重写了compareTo() 方法，所以可以直接使用Collections.sort()方法进行排序，当两个String对象进行比较时，底层实际是通过从前往后比较每个char字符的Unicode值大小。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
        
      public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    } 
   // ...其他代码省略
}

接着，我们再来自己定义一个Person类来进一步说明：

public class Person implements Comparable<Person> {

    String name;
    int age;

    public Person() {
    }

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

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

    /**
     * 要求：先按照age从小到大，age相同时，再按照name从大到小排序
     *
     * @param p 和 this对象进行比较的对象
     * @return
     * 返回1:  this大于p
     * 返回0:  this等于p
     * 返回-1: this小于p
     */
    @Override
    public int compareTo(Person p) {
        if (this.age != p.age) {
            return Integer.compare(this.age, p.age);
        } else {
            //注意这里加 “-”号
            return -this.name.compareTo(p.name);
        }
    }

}

下面进行测试：

@Test
public void test02() {
    List<Person> list = new ArrayList<>();
    list.add(new Person("aa", 20));
    list.add(new Person("cc", 12));
    list.add(new Person("bb", 17));
    list.add(new Person("dd", 18));
    list.add(new Person("ee", 18));

    System.out.println("before:" + list);
    Collections.sort(list);
    System.out.println("after:" + list);
}

输出结果：
before:[Person{name='aa', age=20}, Person{name='cc', age=12}, Person{name='bb', age=17}, Person{name='dd', age=18}, Person{name='ee', age=18}]
after:[Person{name='cc', age=12}, Person{name='bb', age=17}, Person{name='ee', age=18}, Person{name='dd', age=18}, Person{name='aa', age=20}]

但是，实现Comparable的方式也有一些局限性，对于一些特殊场合，如果不想使用原来类中定义的比较方式，而是想使用其他比较方式，又或者想用于比较的对象是第三方库的类，不能进行修改的情况，实现Comparable的方式就不太适合了，这时就可以使用Java提供的第二种排序方式：Comparator。

（2）Comparator（定制排序）

java.util.Comparator 字面意思是比较器，是用来对两个对象进行比较的工具（可以认为是在对象外部排序）。

/**
 * 要求：使用定制排序：先按照name从小到大，name相同时，再按照age从大到小排序
 */
@Test
public void test04() {
    List<Person> list = new ArrayList<>();
    list.add(new Person("aa", 20));
    list.add(new Person("cc", 12));
    list.add(new Person("bb", 17));
    list.add(new Person("ee", 18));
    list.add(new Person("dd", 18));

    System.out.println("before:" + list);
    //因为只使用一次，所以可以使用匿名内部类的方式
    Collections.sort(list, new Comparator<Person>() {
        @Override
        public int compare(Person o1, Person o2) {
            //这里就没有判空了
            if (!o1.name.equals(o2.name)) {
                return o1.name.compareTo(o2.name);
            } else {
                //名字相同就比较年龄,注意这里要加“-”号
                return -Integer.compare(o1.age, o2.age);
            }
        }
    });
    System.out.println("after:" + list);
}

输出结果：
before:[Person{name='aa', age=20}, Person{name='cc', age=12}, Person{name='bb', age=17}, Person{name='ee', age=18}, Person{name='dd', age=18}]
after:[Person{name='aa', age=20}, Person{name='bb', age=17}, Person{name='cc', age=12}, Person{name='dd', age=18}, Person{name='ee', age=18}]

（3）两种方式对比总结：

（1）从名称中可以看出，Comparable以“able”结尾，意思是“可xxx的”，java中也有很多其他类似命令的类，如：Cloneable等。他们的意思基本都是用来定义一种规范或声明，具体的实现细节由实现类来完成。而Comparator是以“or”结尾，一般指的是该类是一个工具型的类。类似的也有：Executor等。

（2）当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序

（3）a. 重写compareTo(Object obj)方法时：

如果当前对象this大于形参obj，则返回正整数；
如果当前对象this等于形参obj，则返回0；
如果当前对象this小于形参obj，则返回负整数。

b. 重写compare(Object o1,Object o2)方法：

如果o1大于o2，则返回正整数；
如果 o1等于o2，则返回0；
如果 o1小于o2，则返回负整数。

记忆方法：可以认为：返回数的值 = 前面对象 - 后面对象。

（4）Java中的包装类和String都实现了Comparable接口，重写了compareTo(Object obj)方法，实现了比较两个对象大小的方式。其中：

String：按照字符串中每个字符的Unicode编码值进行比较；
Character：按照字符的Unicode编码值进行比较；
Integer、Long、Float、Double、Byte等数值类型对应的包装类：按照他们对应的数值大小进行比较
Boolean：true对应的包装类实例 > false对应的包装类实例;
Date、Time等日期时间类：后面的日期大于前面的日期大小（实际比较的是它们对应的时间戳大小）。

（5）实现了Comparable接口的类或者使用调用带Comparator实现类的方式，都可以使用java中的Arrays.sort()方法，或者Collections.sort()方法对多个对象进行排序，Collections.sort() 底层其实也是使用的Arrays.sort()，底层实际就是使用对象实现的compareTo(Object obj)或compare(Object o1, Object o2)方法对数组或集合进行排序。可以参考另一篇文章：https://blog.youkuaiyun.com/u011410529/article/details/56668545

（6）由于 null 不是一个类，也不是一个对象，因此在重写 compareTo 方法时应该注意 e.compareTo(null) 的情况，即使 e.equals(null) 返回 false，compareTo 方法也应该主动抛出一个空指针异常 NullPointerException。

（7）Comparable 实现类重写 compareTo 方法时一般要求 e1.compareTo(e2) == 0 的结果要和 e1.equals(e2) 一致。这样将来使用 SortedSet 等根据类的自然排序进行排序的集合容器时可以保证保存的数据的顺序和想象中一致。

参考地址：

Java 解惑：Comparable 和 Comparator 的区别：https://zhuanlan.zhihu.com/p/24081048

Arrays.sort和Collections.sort实现原理解析：https://blog.youkuaiyun.com/u011410529/article/details/56668545