模块 java.base
包 java.util

接口 Comparator<T>

类型参数：
T - 此比较器可以比较的对象类型
所有已知的实现类：
Collator , RuleBasedCollator
函数接口：
这是一个功能接口，因此可以用作 lambda 表达式或方法引用的赋值目标。
@FunctionalInterface public interface Comparator<T>
一个比较函数，它强加了一个总订购在一些对象集合上。可以将比较器传递给排序方法（例如 Collections.sort 或 Arrays.sort ）以允许精确控制排序顺序。比较器还可用于控制某些数据结构的顺序（例如 排序集 或 分类map ），或为没有 自然排序 的对象集合提供顺序。

比较器 c 对一组元素 S 施加的排序据说是一致当且仅当 c.compare(e1, e2)==0 对于 S 中的每个 e1 和 e2 具有与 e1.equals(e2) 相同的boolean。

当使用能够强加与 equals 不一致的排序的比较器来排序有序集（或有序映射）时，应该谨慎行事。假设一个带有显式比较器 c 的有序集合（或有序映射）与从集合 S 中提取的元素（或键）一起使用。如果 c 对 S 施加的排序与 equals 不一致，排序集（或排序映射）将表现得“奇怪”。特别是排序集（或排序映射）将违反集合（或映射）的一般合同，这是根据 equals 定义的。

例如，假设将两个元素 a 和 b 添加到一个带有比较器 c 的空 TreeSet 中 (a.equals(b) && c.compare(a, b) != 0) 。第二个 add 操作将返回 true（并且树集的大小将增加），因为从树集的角度来看 a 和 b 不等价，即使这与 Set.add 方法的规范相反。

注意：比较器也实现 java.io.Serializable 通常是个好主意，因为它们可以用作可序列化数据结构（如 TreeSet 、 TreeMap ）中的排序方法。为了使数据结构成功序列化，比较器（如果提供）必须实现 Serializable 。

对于喜欢数学的人来说，关系定义了强制排序给定的比较器 c 强加给给定的一组对象 S 是：

    {(x, y) such that c.compare(x, y) <= 0}.
的商对于这个总订单是： 
    {(x, y) such that c.compare(x, y) == 0}.
它立即从 compare 的合同得出商是等价关系在 S 上，强加的顺序是总订单在 S 上。当我们说 c 对 S 施加的排序是一致，我们的意思是排序的商是由对象的equals(Object) 方法定义的等价关系： 
   {(x, y) such that x.equals(y)}.
换句话说，当强加的排序与equals一致时，由equals方法的等价关系定义的等价类和compare方法的商定义的等价类是一样的。

与 Comparable 不同，比较器可以选择允许比较空参数，同时保持对等价关系的要求。

此接口是 Java 集合框架 的成员。

自从：
1.2
参见：

  • 方法详情

    • compare

      int compare(T  o1, T  o2)
      比较其两个参数的顺序。当第一个参数小于、等于或大于第二个参数时，返回负整数、零或正整数。

      实施者必须确保 signum (compare(x, y)) == -signum(compare(y, x)) 对于所有 x 和 y。 （这意味着当且仅当 compare(y, x) 抛出异常时 compare(x, y) 必须抛出异常。）

      实现者还必须确保该关系是可传递的：((compare(x, y)>0) && (compare(y, z)>0)) 表示 compare(x, z)>0。

      最后，实施者必须确保 compare(x, y)==0 暗示所有 z 的 signum(compare(x, z))==signum(compare(y, z))。

      API 注意：
      一般都是这样，但是not严格要求 (compare(x, y)==0) == (x.equals(y)) 。一般来说，任何违反此条件的比较器都应清楚地表明这一事实。推荐的语言是“注意：这个比较器强加了与 equals 不一致的顺序。”
      参数：
      o1 - 要比较的第一个对象。
      o2 - 要比较的第二个对象。
      返回：
      作为第一个参数小于、等于或大于第二个参数的负整数、零或正整数。
      抛出：
      NullPointerException - 如果参数为空且此比较器不允许空参数
      ClassCastException - 如果参数的类型阻止它们被这个比较器比较。

    • equals

      boolean equals(Object  obj)
      指示某个其他对象是否“等于”此比较器。此方法必须遵守 Object.equals(Object) 的一般契约。此外，此方法可以返回 true仅有的如果指定的对象也是一个比较器，并且它强加与此比较器相同的顺序。因此，comp1.equals(comp2) 意味着 signum (comp1.compare(o1, o2))==signum(comp2.compare(o1, o2)) 对于每个对象引用 o1 和 o2。

      请注意，它是总是safenot覆盖 Object.equals(Object) 。但是，在某些情况下，重写此方法可以通过允许程序确定两个不同的比较器强加相同的顺序来提高性能。

      重写：
      equals 在类 Object 中
      参数：
      obj - 要比较的参考对象。
      返回：
      true 仅当指定的对象也是比较器并且它强加与此比较器相同的顺序时。
      参见：

    • reversed

      default Comparator <T > reversed()
      返回一个比较器，该比较器强加此比较器的反向排序。
      返回：
      强加此比较器的反向排序的比较器。
      自从：
      1.8

    • thenComparing

      default Comparator <T > thenComparing(Comparator <? super T > other)
      返回带有另一个比较器的字典顺序比较器。如果这个 Comparator 认为两个元素相等，即 compare(a, b) == 0 ，则使用 other 来确定顺序。

      如果指定的比较器也是可序列化的，则返回的比较器是可序列化的。

      API 注意：
      例如，要根据长度对 String 的集合进行排序，然后进行不区分大小写的自然排序，可以使用以下代码组成比较器， 
      
   Comparator<String> cmp = Comparator.comparingInt(String::length)
       .thenComparing(String.CASE_INSENSITIVE_ORDER);
      参数：
      other - 当此比较器比较两个相等的对象时要使用的另一个比较器。
      返回：
      由这个和另一个比较器组成的字典顺序比较器
      抛出：
      NullPointerException - 如果参数为空。
      自从：
      1.8

    • thenComparing

      default <U> Comparator <T > thenComparing(Function <? super T ,? extends U> keyExtractor, Comparator <? super U> keyComparator)
      返回一个字典顺序比较器，该比较器具有一个函数，该函数提取要与给定的 Comparator 进行比较的键。
      实现要求：
      此默认实现的行为就像 thenComparing(comparing(keyExtractor, cmp)) 。
      类型参数：
      U - 排序键的类型
      参数：
      keyExtractor - 用于提取排序键的函数
      keyComparator - Comparator 用于比较排序键
      返回：
      由这个比较器组成的字典顺序比较器，然后比较由 keyExtractor 函数提取的键
      抛出：
      NullPointerException - 如果任一参数为空。
      自从：
      1.8
      参见：

    • thenComparing

      default <U extends Comparable <? super U>> Comparator <T > thenComparing(Function <? super T ,? extends U> keyExtractor)
      返回具有提取Comparable排序键的函数的词典顺序比较器。
      实现要求：
      此默认实现的行为就像 thenComparing(comparing(keyExtractor)) 。
      类型参数：
      U - Comparable 排序键的类型
      参数：
      keyExtractor - 用于提取 Comparable 排序键的函数
      返回：
      由它和 Comparable 排序键组成的词典顺序比较器。
      抛出：
      NullPointerException - 如果参数为空。
      自从：
      1.8
      参见：

    • thenComparingInt

      default Comparator <T > thenComparingInt(ToIntFunction <? super T > keyExtractor)
      返回具有提取 int 排序键的函数的词典顺序比较器。
      实现要求：
      此默认实现的行为就像 thenComparing(comparingInt(keyExtractor)) 。
      参数：
      keyExtractor - 用于提取整数排序键的函数
      返回：
      由这个和 int 排序键组成的词典顺序比较器
      抛出：
      NullPointerException - 如果参数为空。
      自从：
      1.8
      参见：

    • thenComparingLong

      default Comparator <T > thenComparingLong(ToLongFunction <? super T > keyExtractor)
      返回具有提取 long 排序键的函数的词典顺序比较器。
      实现要求：
      此默认实现的行为就像 thenComparing(comparingLong(keyExtractor)) 。
      参数：
      keyExtractor - 用于提取长排序键的函数
      返回：
      由这个和 long 排序键组成的词典顺序比较器
      抛出：
      NullPointerException - 如果参数为空。
      自从：
      1.8
      参见：

    • thenComparingDouble

      default Comparator <T > thenComparingDouble(ToDoubleFunction <? super T > keyExtractor)
      返回具有提取 double 排序键的函数的词典顺序比较器。
      实现要求：
      此默认实现的行为就像 thenComparing(comparingDouble(keyExtractor)) 。
      参数：
      keyExtractor - 用于提取双排序键的函数
      返回：
      由这个和 double 排序键组成的词典顺序比较器
      抛出：
      NullPointerException - 如果参数为空。
      自从：
      1.8
      参见：

    • reverseOrder

      static <T extends Comparable <? super T>> Comparator <T> reverseOrder()
      返回一个强加 natural ordering 反转的比较器。

      返回的比较器是可序列化的，并在比较 null 时抛出 NullPointerException 。

      类型参数：
      T - 要比较的元素的 Comparable 类型
      返回：
      施加相反的比较器自然排序在 Comparable 个对象上。
      自从：
      1.8
      参见：

    • naturalOrder

      static <T extends Comparable <? super T>> Comparator <T> naturalOrder()
      返回一个以自然顺序比较 Comparable 对象的比较器。

      返回的比较器是可序列化的，并在比较 null 时抛出 NullPointerException 。

      类型参数：
      T - 要比较的元素的 Comparable 类型
      返回：
      一个比较器，它施加了自然排序在 Comparable 个对象上。
      自从：
      1.8
      参见：

    • nullsFirst

      static <T> Comparator <T> nullsFirst(Comparator <? super T> comparator)
      返回一个空友好比较器，它认为 null 小于非空。当两者都是 null 时，它们被认为是相等的。如果两者都不为空，则使用指定的 Comparator 来确定顺序。如果指定的比较器是 null ，则返回的比较器认为所有非空值都相等。

      如果指定的比较器是可序列化的，则返回的比较器是可序列化的。

      类型参数：
      T - 要比较的元素的类型
      参数：
      comparator - 用于比较非空值的 Comparator
      返回：
      一个比较器，它认为 null 小于非空，并将非空对象与提供的 Comparator 进行比较。
      自从：
      1.8

    • nullsLast

      static <T> Comparator <T> nullsLast(Comparator <? super T> comparator)
      返回一个空友好比较器，它认为 null 大于非空。当两者都是 null 时，它们被认为是相等的。如果两者都不为空，则使用指定的 Comparator 来确定顺序。如果指定的比较器是 null ，则返回的比较器认为所有非空值都相等。

      如果指定的比较器是可序列化的，则返回的比较器是可序列化的。

      类型参数：
      T - 要比较的元素的类型
      参数：
      comparator - 用于比较非空值的 Comparator
      返回：
      一个比较器，它认为 null 大于非空，并将非空对象与提供的 Comparator 进行比较。
      自从：
      1.8

    • comparing

      static <T, U> Comparator <T> comparing(Function <? super T,? extends U> keyExtractor, Comparator <? super U> keyComparator)
      接受一个函数，该函数从类型 T 中提取排序键，并返回一个 Comparator<T>，它使用指定的 Comparator 通过该排序键进行比较。

      如果指定的函数和比较器都是可序列化的，则返回的比较器是可序列化的。

      API 注意：
      例如，要获得一个 Comparator，它通过忽略大小写差异的姓氏比较 Person 个对象， 
      
   Comparator<Person> cmp = Comparator.comparing(
       Person::getLastName,
       String.CASE_INSENSITIVE_ORDER);
      类型参数：
      T - 要比较的元素类型
      U - 排序键的类型
      参数：
      keyExtractor - 用于提取排序键的函数
      keyComparator - Comparator 用于比较排序键
      返回：
      使用指定的 Comparator 通过提取的键进行比较的比较器
      抛出：
      NullPointerException - 如果任一参数为空
      自从：
      1.8

    • comparing

      static <T, U extends Comparable <? super U>> Comparator <T> comparing(Function <? super T,? extends U> keyExtractor)
      接受一个函数，该函数从类型 T 中提取 Comparable 排序键，并返回与该排序键进行比较的 Comparator<T>。

      如果指定的函数也是可序列化的，则返回的比较器是可序列化的。

      API 注意：
      例如，要获得一个 Comparator 来比较 Person 个对象的姓氏， 
      
   Comparator<Person> byLastName = Comparator.comparing(Person::getLastName);
      类型参数：
      T - 要比较的元素类型
      U - Comparable 排序键的类型
      参数：
      keyExtractor - 用于提取 Comparable 排序键的函数
      返回：
      通过提取的键进行比较的比较器
      抛出：
      NullPointerException - 如果参数为空
      自从：
      1.8

    • comparingInt

      static <T> Comparator <T> comparingInt(ToIntFunction <? super T> keyExtractor)
      接受一个函数，该函数从类型 T 中提取 int 排序键，并返回与该排序键进行比较的 Comparator<T>。

      如果指定的函数也是可序列化的，则返回的比较器是可序列化的。

      类型参数：
      T - 要比较的元素类型
      参数：
      keyExtractor - 用于提取整数排序键的函数
      返回：
      通过提取的键进行比较的比较器
      抛出：
      NullPointerException - 如果参数为空
      自从：
      1.8
      参见：

    • comparingLong

      static <T> Comparator <T> comparingLong(ToLongFunction <? super T> keyExtractor)
      接受一个函数，该函数从类型 T 中提取 long 排序键，并返回与该排序键进行比较的 Comparator<T>。

      如果指定的函数也是可序列化的，则返回的比较器是可序列化的。

      类型参数：
      T - 要比较的元素类型
      参数：
      keyExtractor - 用于提取长排序键的函数
      返回：
      通过提取的键进行比较的比较器
      抛出：
      NullPointerException - 如果参数为空
      自从：
      1.8
      参见：

    • comparingDouble

      static <T> Comparator <T> comparingDouble(ToDoubleFunction <? super T> keyExtractor)
      接受一个函数，该函数从类型 T 中提取 double 排序键，并返回与该排序键进行比较的 Comparator<T>。

      如果指定的函数也是可序列化的，则返回的比较器是可序列化的。

      类型参数：
      T - 要比较的元素类型
      参数：
      keyExtractor - 用于提取双排序键的函数
      返回：
      通过提取的键进行比较的比较器
      抛出：
      NullPointerException - 如果参数为空
      自从：
      1.8
      参见：