Comparable和Comparator

花花无缺
108 阅读7分钟

Comparable 和 Comparator 是 Java 中用于对象排序的两个重要接口。它们都定义了比较对象的方法，但使用场景和方式有所不同。

1. Comparable 接口

  • 定义位置: java.lang.Comparable

  • 核心方法: int compareTo(T o)

  • 特点:

    • 自然排序 (Natural Ordering) : 实现 Comparable 接口的类定义了其对象的“自然顺序”。例如，String 按字典序，Integer 按数值大小。
    • 内建于类中: 需要排序的类本身必须实现 Comparable 接口，并重写 compareTo 方法。
    • 单一排序逻辑: 一个类通常只能定义一种 compareTo 方式（即一种自然排序）。
    • 使用方式: 实现了 Comparable 的类的对象可以直接用于需要排序的集合中，如 Collections.sort(list) 或 Arrays.sort(array)。

  • compareTo 方法返回值:

    • 负整数: 当前对象小于参数对象。
    • 零: 当前对象等于参数对象。
    • 正整数: 当前对象大于参数对象。

  • 示例:

 public class Person implements Comparable<Person> {
     private String name;
     private int age;

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

     // 按年龄排序作为自然顺序
     @Override
     public int compareTo(Person other) {
         return Integer.compare(this.age, other.age); // 年龄升序
         // return this.name.compareTo(other.name); // 也可以按名字排序
     }

     @Override
     public String toString() {
         return name + "(" + age + ")";
     }
 }

 // 使用
 List<Person> people = Arrays.asList(
     new Person("Alice", 30),
     new Person("Bob", 25),
     new Person("Charlie", 35)
 );
 Collections.sort(people); // 可以直接排序，因为 Person 实现了 Comparable
 System.out.println(people); // 输出: [Bob(25), Alice(30), Charlie(35)]

2. Comparator 接口

  • 定义位置: java.util.Comparator

  • 核心方法: int compare(T o1, T o2)

  • 特点:

    • 定制排序 (Custom Ordering) : 提供了一种外部的、独立于类本身的排序方式。可以在不修改类定义的情况下，为同一个类的对象定义多种不同的排序规则。
    • 独立于类: Comparator 是一个独立的接口，通常以匿名内部类、Lambda 表达式或独立的类/方法形式存在。
    • 多种排序逻辑: 可以为同一个类创建多个不同的 Comparator 实例，实现不同的排序需求（如按姓名、按年龄、按身高、升序、降序等）。
    • 使用方式: 通常作为参数传递给排序方法，如 Collections.sort(list, comparator) 或 Arrays.sort(array, comparator)。也可以用于 TreeSet、TreeMap 的构造函数中指定排序规则。

  • compare 方法返回值:

    • 负整数: 第一个对象小于第二个对象。
    • 零: 两个对象相等。
    • 正整数: 第一个对象大于第二个对象。

  • 示例:

  // 假设 Person 类没有实现 Comparable，或者我们想用不同于自然顺序的方式排序

  // 方式1: 匿名内部类 (较老)
  Comparator<Person> byName = new Comparator<Person>() {
      @Override
      public int compare(Person p1, Person p2) {
          return p1.getName().compareTo(p2.getName());
      }
  };

  // 方式2: Lambda 表达式 (推荐)
  Comparator<Person> byAgeAsc = (p1, p2) -> Integer.compare(p1.getAge(), p2.getAge());
  Comparator<Person> byAgeDesc = (p1, p2) -> Integer.compare(p2.getAge(), p1.getAge()); // 注意参数顺序
  // 或者使用 Comparator 的静态方法
  Comparator<Person> byNameAsc = Comparator.comparing(Person::getName);
  Comparator<Person> byNameDesc = Comparator.comparing(Person::getName).reversed();
  Comparator<Person> byAgeThenName = Comparator.comparing(Person::getAge)
                                             .thenComparing(Person::getName);

  // 使用
  List<Person> people = Arrays.asList(
      new Person("Alice", 30),
      new Person("Bob", 25),
      new Person("Charlie", 35),
      new Person("Alice", 20)
  );

  Collections.sort(people, byNameAsc); // 按名字排序
  System.out.println(people); // [Alice(20), Alice(30), Bob(25), Charlie(35)]

  Collections.sort(people, byAgeAsc); // 按年龄排序
  System.out.println(people); // [Alice(20), Bob(25), Alice(30), Charlie(35)]

  Collections.sort(people, byAgeThenName); // 先按年龄，年龄相同再按名字
  System.out.println(people); // [Alice(20), Bob(25), Alice(30), Charlie(35)]

主要区别总结

特性ComparableComparator
包java.langjava.util
方法int compareTo(T o)int compare(T o1, T o2)
排序类型自然排序 (Natural Ordering)定制排序 (Custom Ordering)
实现位置被比较的类自身实现独立的类、方法、Lambda 表达式
灵活性通常一个类只有一种自然排序可以为一个类定义多种不同的排序规则
修改类需要修改目标类的源码无需修改目标类源码
常用场景类有明确的、公认的排序标准需要多种排序方式，或对第三方类进行排序
调用方式Collections.sort(list)Collections.sort(list, comparator)

何时使用？

  • 使用 Comparable: 当一个类的对象有一个非常明确、通用的排序标准时（例如，人的年龄、学生的学号、商品的价格），可以将其定义为该类的自然顺序。
  • 使用 Comparator: 当需要多种排序方式、排序标准不固定、或者需要对没有实现 Comparable 的类（包括第三方库的类）进行排序时。Java 8 引入的 Lambda 表达式和 Comparator 的静态/默认方法（如 comparing, reversed, thenComparing）使得创建 Comparator 变得非常简洁和强大。

进一步直观感受Comparable和Comparator

例1：

图片.png 这段代码中使用的是 Comparator。

sorted() 方法的参数： Stream 的 sorted() 方法有两种重载形式：

  • sorted(): 用于元素实现了 Comparable 接口的流，它使用元素的自然顺序（compareTo 方法）进行排序。
  • sorted(Comparator<? super T> comparator): 接收一个 Comparator 实例作为参数，用于定义自定义的排序规则。

在上面代码中，sorted() 方法接收了一个 Lambda 表达式 (a,b) -> { ... } 作为参数。这个 Lambda 表达式实现了 Comparator<String> 接口的 compare(T o1, T o2) 方法。

这个 Lambda 表达式定义了如何比较两个 String（a 和 b）。它根据 personBagMap 中存储的数值（getKey() 对应 x.get(i)）和索引（getValue() 对应 i）来决定排序顺序：

  • 如果数值 (x.get(i)) 相同，则按索引升序排列。
  • 如果数值不同，则按数值降序排列（注意是 entryB.getKey() - entryA.getKey()）。

这个比较逻辑是自定义的，并且是外部于 String 类本身的。String 类的自然顺序是字典序（lexicographical order），而这里的排序规则完全不同。

例2：

Collections.sort() 方法 既可以使用 Comparable，也可以使用 Comparator，它有两种重载形式：

    1. 使用 Comparable (自然排序)

    • 方法签名: public static <T extends Comparable<? super T>> void sort(List<T> list)

    • 工作原理: 这个版本要求列表 list 中的元素类型 T 必须实现 Comparable<T> 接口。

    • 排序依据: 方法内部会调用列表中每个元素的 compareTo() 方法来比较元素并进行排序。这种排序称为自然排序 (Natural Ordering) 。

  • 示例:

    List<String> words = Arrays.asList("banana", "apple", "cherry");
    Collections.sort(words); // 使用 String 的 compareTo() 方法（字典序）
    System.out.println(words); // 输出: [apple, banana, cherry]

    List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5);
    Collections.sort(numbers); // 使用 Integer 的 compareTo() 方法（数值大小）
    System.out.println(numbers); // 输出: [1, 1, 3, 4, 5]

在这些例子中，String 和 Integer 都实现了 Comparable，所以 Collections.sort(list) 直接使用了它们的 compareTo 方法。

    1. 使用 Comparator (定制排序)

    • 方法签名: public static <T> void sort(List<T> list, Comparator<? super T> c)

    • 工作原理: 这个版本接收一个额外的参数 c，即一个 Comparator 对象。

    • 排序依据: 方法内部会使用传入的 Comparator 对象的 compare() 方法来比较列表中的元素。这允许你定义自定义的、非自然的排序规则。

  • 示例:

List<String> words = Arrays.asList("banana", "apple", "cherry");

// 按字符串长度排序（升序）
Collections.sort(words, (a, b) -> Integer.compare(a.length(), b.length()));
System.out.println(words); // 输出: [apple, banana, cherry] (apple 和 cherry 都是5个字母，banana是6个)

// 按字符串长度排序（降序）
Collections.sort(words, (a, b) -> Integer.compare(b.length(), a.length()));
System.out.println(words); // 输出: [banana, apple, cherry]

// 按字典序降序排序
Collections.sort(words, Comparator.reverseOrder());
System.out.println(words); // 输出: [cherry, banana, apple]

在这些例子中，排序规则由传入的 Comparator（可以是 Lambda 表达式、方法引用或 Comparator 实例）决定，而不是元素的自然顺序。

为什么实现比较效果，有时候看到用a-b,有时候compare(a,b)？

在早期或一些简单的代码示例中，开发者可能为了简洁和便于理解比较函数返回值的含义而使用 a - b，尤其是在处理范围较小的、不太可能溢出的数值时。或者在非常确定数值范围不会导致溢出的特定场景下，有人可能为了性能（避免方法调用开销，尽管现代JVM优化后差异极小）而选择 a - b，但这通常不被推荐。

a-b 方式的缺点和风险:

  • 仅限数值: 只能用于可以进行减法运算的类型（主要是数值类型）。你不能对 String 或自定义对象做 a - b。

  • 整数溢出 (Integer Overflow) : 这是最大的风险！当 a 是一个很大的正数，b 是一个很大的负数（或反之）时，a - b 的结果可能会超出 int 类型的范围，导致溢出，产生错误的结果（例如，正数减负数可能得到一个负数）。

示例 (有风险): 这个排序可能会因为 Integer.MAX_VALUE - (-1) 溢出而产生不可预测的结果。

List<Integer> numbers = Arrays.asList(Integer.MAX_VALUE, -1, 0);
// 危险！可能导致错误排序
numbers.sort((a, b) -> a - b); // 不推荐！
特性compare(a, b) / Integer.compare(a, b)a - b
本质方法调用算术运算
类型通用 (对象、数值)仅限数值类型
安全性高 (避免溢出)低 (有溢出风险)
推荐程度强烈推荐不推荐 (除非绝对确定无溢出且追求极致微优化)
语义明确表示"比较"表示"减法"
  • 核心原则：为了代码的健壮性和可维护性，请始终使用 Comparator.compare() 或其静态方法（如 Integer.compare()），避免使用 a - b 进行比较。
avatar
文章
阅读
粉丝