类型参数:: T - 可以通过此比较器进行比较的对象的类型

所有已知的实现类:: Collator, RuleBasedCollator

函数式接口:: 这是一个函数式接口，因此可以用作lambda表达式或方法引用的赋值目标。

@FunctionalInterface public interface Comparator<T>

一个比较函数，对一些对象集合施加了完全排序。比较器可以传递给排序方法（例如Collections.sort或Arrays.sort），以允许精确控制排序顺序。比较器还可以用于控制某些数据结构的顺序（例如排序集合或排序映射），或为没有自然排序的对象集合提供排序。

比较器 c 对元素集 S 施加的排序被称为与等号一致，当且仅当 c.compare(e1, e2)==0 对于 S 中的每个 e1 和 e2 具有与 e1.equals(e2) 相同的布尔值。

在使用能够施加与等号不一致的排序的比较器对排序集合（或排序映射）进行排序时应谨慎。假设使用具有显式比较器 c 的排序集合（或排序映射）与从集合 S 中提取的元素（或键）。如果 c 对 S 施加的排序与等号不一致，则排序集合（或排序映射）将表现“奇怪”。特别是排序集合（或排序映射）将违反集合（或映射）的一般契约，该契约是根据 equals 定义的。

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

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

对于数学倾向的人，给定比较器 c 对一组对象 S 施加的强制排序的关系是：

       {(x, y)使得c.compare(x, y) <= 0}。

这个总排序的商是：

       {(x, y)使得c.compare(x, y) == 0}。

从 compare 的合同立即得出，商是 S 上的等价关系，并且强制排序是 S 上的全序。当我们说比较器 c 对 S 施加的排序与等号一致时，我们的意思是排序的商是由对象的equals(Object)方法定义的等价关系：

     {(x, y)使得x.equals(y)}。

换句话说，当强制排序与等号一致时，由equals方法定义的等价关系和compare方法的商定义的等价关系是相同的。

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

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

自版本:

1.2

参见:

Method Summary

Modifier and Type

Method

Description

int

compare(T o1, T o2)

比较其两个参数的顺序。

static <T, U extends Comparable<? super U>> Comparator<T>

comparing(Function<? super T,? extends U> keyExtractor)

接受一个从类型T中提取Comparable排序键的函数，并返回一个按照该排序键进行比较的Comparator<T>。

static <T, U> Comparator<T>

comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)

接受一个从类型T中提取排序键的函数，并返回一个使用指定Comparator进行比较的Comparator<T>。

static <T> Comparator<T>

comparingDouble(ToDoubleFunction<? super T> keyExtractor)

接受一个从类型T中提取double排序键的函数，并返回一个按照该排序键进行比较的Comparator<T>。

static <T> Comparator<T>

comparingInt(ToIntFunction<? super T> keyExtractor)

接受一个从类型T中提取int排序键的函数，并返回一个按照该排序键进行比较的Comparator<T>。

static <T> Comparator<T>

comparingLong(ToLongFunction<? super T> keyExtractor)

接受一个从类型T中提取long排序键的函数，并返回一个按照该排序键进行比较的Comparator<T>。

boolean

equals(Object obj)

指示某个其他对象是否与此比较器“相等”。

static <T extends Comparable<? super T>> Comparator<T>

naturalOrder()

返回一个按照自然顺序比较Comparable对象的比较器。

static <T> Comparator<T>

nullsFirst(Comparator<? super T> comparator)

返回一个对null友好的比较器，将null视为小于非空值。

static <T> Comparator<T>

nullsLast(Comparator<? super T> comparator)

返回一个对null友好的比较器，将null视为大于非空值。

default Comparator<T>

reversed()

返回一个施加此比较器的反向排序的比较器。

static <T extends Comparable<? super T>> Comparator<T>

reverseOrder()

返回一个施加自然顺序的反向排序的比较器。

default Comparator<T>

thenComparing(Comparator<? super T> other)

返回一个具有另一个比较器的字典顺序比较器。

default <U extends Comparable<? super U>> Comparator<T>

thenComparing(Function<? super T,? extends U> keyExtractor)

返回一个具有从函数中提取Comparable排序键的字典顺序比较器。

default <U> Comparator<T>

thenComparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)

返回一个具有从函数中提取要与给定Comparator进行比较的键的字典顺序比较器。

default Comparator<T>

thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)

返回一个具有从函数中提取double排序键的字典顺序比较器。

default Comparator<T>

thenComparingInt(ToIntFunction<? super T> keyExtractor)

返回一个具有从函数中提取int排序键的字典顺序比较器。

default Comparator<T>

thenComparingLong(ToLongFunction<? super T> keyExtractor)

返回一个具有从函数中提取long排序键的字典顺序比较器。

Method Details
- compare
  
  int compare(T o1, T o2)
  
  比较其两个参数的顺序。返回负整数、零或正整数，如果第一个参数小于、等于或大于第二个参数。
  实现者必须确保对于所有x和y，signum(compare(x, y)) == -signum(compare(y, x))。（这意味着如果且仅当 compare(y, x)抛出异常时， compare(x, y)必须抛出异常。）
  
  实现者还必须确保关系是传递的：((compare(x, y)>0) && (compare(y, z)>0))意味着compare(x, z)>0。
  
  最后，实现者必须确保compare(x, y)==0意味着signum(compare(x, z))==signum(compare(y, z))对于所有z。
  
  API注释:
  
  通常情况下，但不是严格要求，(compare(x, y)==0) == (x.equals(y))。一般来说，任何违反此条件的比较器应清楚指出这一事实。推荐的语言是“注意：此比较器施加的排序与等号不一致。”
  
  参数:
  
  o1 - 要比较的第一个对象。
  
  o2 - 要比较的第二个对象。
  
  返回:
  
  一个负整数、零或正整数，如果第一个参数小于、等于或大于第二个参数。
  
  抛出:
  
  NullPointerException - 如果参数为null且此比较器不允许空参数
  
  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。
  请注意，始终安全地不覆盖Object.equals(Object)。但是，在某些情况下，覆盖此方法可能会提高性能，因为允许程序确定两个不同的比较器是否施加相同的顺序。
  覆盖:
  
  equals 在类 Object
  
  参数:
  
  obj - 要比较的参考对象。
  
  返回:
  
  true只有当指定的对象也是比较器并且它施加与此比较器相同的排序时。
  
  参见:
  
  Object.equals(Object)
  
  Object.hashCode()
- 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 - 如果参数为null。
  
  自从:
  
  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 - 如果任一参数为null。
  
  自从:
  
  1.8
  
  另请参阅:
  
  comparing(Function, Comparator)
  
  thenComparing(Comparator)
- 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 - 如果参数为null。
  
  自从:
  
  1.8
  
  另请参阅:
  
  comparing(Function)
  
  thenComparing(Comparator)
- thenComparingInt
  
  default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor)
  
  返回一个从函数中提取int排序键的按字典顺序比较器。
  实现要求:
  
  这个默认实现的行为就像 thenComparing(comparingInt(keyExtractor))。
  
  参数:
  
  keyExtractor - 用于提取整数排序键的函数
  
  返回:
  
  由这个比较器和然后int排序键进行比较的按字典顺序比较器
  
  抛出:
  
  NullPointerException - 如果参数为null。
  
  自从:
  
  1.8
  
  另请参阅:
  
  comparingInt(ToIntFunction)
  
  thenComparing(Comparator)
- thenComparingLong
  
  default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor)
  
  返回一个从函数中提取long排序键的按字典顺序比较器。
  实现要求:
  
  这个默认实现的行为就像 thenComparing(comparingLong(keyExtractor))。
  
  参数:
  
  keyExtractor - 用于提取长整型排序键的函数
  
  返回:
  
  由这个比较器和然后long排序键进行比较的按字典顺序比较器
  
  抛出:
  
  NullPointerException - 如果参数为null。
  
  自从:
  
  1.8
  
  另请参阅:
  
  comparingLong(ToLongFunction)
  
  thenComparing(Comparator)
- thenComparingDouble
  
  default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)
  
  返回一个从函数中提取double排序键的按字典顺序比较器。
  实现要求:
  
  这个默认实现的行为就像 thenComparing(comparingDouble(keyExtractor))。
  
  参数:
  
  keyExtractor - 用于提取双精度浮点数排序键的函数
  
  返回:
  
  由这个比较器和然后double排序键进行比较的按字典顺序比较器
  
  抛出:
  
  NullPointerException - 如果参数为null。
  
  自从:
  
  1.8
  
  另请参阅:
  
  comparingDouble(ToDoubleFunction)
  
  thenComparing(Comparator)
- reverseOrder
  
  static <T extends Comparable<? super T>> Comparator<T> reverseOrder()
  
  返回一个施加自然顺序的相反顺序的比较器。
  返回的比较器是可序列化的，并在比较null时抛出NullPointerException。
  类型参数:
  
  T - 要比较的元素的Comparable类型
  
  返回:
  
  一个比较器，对Comparable对象施加自然顺序的相反顺序。
  
  自从:
  
  1.8
  
  另请参阅:
  
  Comparable
- naturalOrder
  
  static <T extends Comparable<? super T>> Comparator<T> naturalOrder()
  
  返回一个比较Comparable对象的自然顺序的比较器。
  返回的比较器是可序列化的，并在比较null时抛出NullPointerException。
  类型参数:
  
  T - 要比较的元素的Comparable类型
  
  返回:
  
  一个比较器，对Comparable对象施加自然顺序。
  
  自从:
  
  1.8
  
  另请参阅:
  
  Comparable
- nullsFirst
  
  static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator)
  
  返回一个空值友好的比较器，将null视为小于非null。当两者都为null时，它们被视为相等。如果两者都为非null，则使用指定的Comparator来确定顺序。如果指定的比较器为null，则返回的比较器将认为所有非null值相等。
  如果指定的比较器也是可序列化的，则返回的比较器也是可序列化的。
  
  类型参数:
  
  T - 要比较的元素的类型
  
  参数:
  
  comparator - 用于比较非null值的Comparator
  
  返回:
  
  一个比较器，将null视为小于非null，并使用提供的Comparator比较非null对象。
  
  自从:
  
  1.8
- nullsLast
  
  static <T> Comparator<T> nullsLast(Comparator<? super T> comparator)
  
  返回一个空值友好的比较器，将null视为大于非null。当两者都为null时，它们被视为相等。如果两者都为非null，则使用指定的Comparator来确定顺序。如果指定的比较器为null，则返回的比较器将认为所有非null值相等。
  如果指定的比较器也是可序列化的，则返回的比较器也是可序列化的。
  
  类型参数:
  
  T - 要比较的元素的类型
  
  参数:
  
  comparator - 用于比较非null值的Comparator
  
  返回:
  
  一个比较器，将null视为大于非null，并使用提供的Comparator比较非null对象。
  
  自从:
  
  1.8
- comparing
  
  static <T, U> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)
  
  接受一个从类型T中提取排序键的函数，并返回一个使用指定Comparator按照该排序键进行比较的Comparator<T>。
  如果指定的函数和比较器都是可序列化的，则返回的比较器也是可序列化的。
  API注释:
  
  例如，要获取一个通过姓氏忽略大小写比较Person对象的Comparator，可以使用以下方式：
  Comparator<Person> cmp = Comparator.comparing( Person::getLastName, String.CASE_INSENSITIVE_ORDER);
  
  类型参数:
  
  T - 要比较的元素类型
  
  U - 排序键的类型
  
  参数:
  
  keyExtractor - 用于提取排序键的函数
  
  keyComparator - 用于比较排序键的Comparator
  
  返回值:
  
  通过指定的Comparator比较提取的键的比较器
  
  抛出:
  
  NullPointerException - 如果任一参数为null
  
  自版本:
  
  1.8
- comparing
  
  static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor)
  
  接受一个从类型T中提取Comparable排序键的函数，并返回一个通过该排序键比较的Comparator<T>。
  如果指定的函数也是可序列化的，则返回的比较器也是可序列化的。
  API注释:
  
  例如，要获取一个通过姓氏比较Person对象的Comparator，可以使用以下方式：
  Comparator<Person> byLastName = Comparator.comparing(Person::getLastName);
  
  类型参数:
  
  T - 要比较的元素类型
  
  U - Comparable排序键的类型
  
  参数:
  
  keyExtractor - 用于提取Comparable排序键的函数
  
  返回值:
  
  通过提取的键进行比较的比较器
  
  抛出:
  
  NullPointerException - 如果参数为null
  
  自版本:
  
  1.8
- comparingInt
  
  static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor)
  
  接受一个从类型T中提取int排序键的函数，并返回一个通过该排序键比较的Comparator<T>。
  如果指定的函数也是可序列化的，则返回的比较器也是可序列化的。
  类型参数:
  
  T - 要比较的元素类型
  
  参数:
  
  keyExtractor - 用于提取整数排序键的函数
  
  返回值:
  
  通过提取的键进行比较的比较器
  
  抛出:
  
  NullPointerException - 如果参数为null
  
  自版本:
  
  1.8
  
  参见:
  
  comparing(Function)
- comparingLong
  
  static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor)
  
  接受一个从类型T中提取long排序键的函数，并返回一个通过该排序键比较的Comparator<T>。
  如果指定的函数也是可序列化的，则返回的比较器也是可序列化的。
  类型参数:
  
  T - 要比较的元素类型
  
  参数:
  
  keyExtractor - 用于提取长整型排序键的函数
  
  返回值:
  
  通过提取的键进行比较的比较器
  
  抛出:
  
  NullPointerException - 如果参数为null
  
  自版本:
  
  1.8
  
  参见:
  
  comparing(Function)
- comparingDouble
  
  static <T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor)
  
  接受一个从类型T中提取double排序键的函数，并返回一个通过该排序键比较的Comparator<T>。
  如果指定的函数也是可序列化的，则返回的比较器也是可序列化的。
  类型参数:
  
  T - 要比较的元素类型
  
  参数:
  
  keyExtractor - 用于提取双精度浮点数排序键的函数
  
  返回值:
  
  通过提取的键进行比较的比较器
  
  抛出:
  
  NullPointerException - 如果参数为null
  
  自版本:
  
  1.8
  
  参见:
  
  comparing(Function)

Interface Comparator<T>

Method Summary

Method Details

compare

equals

reversed

thenComparing

thenComparing

thenComparing

thenComparingInt

thenComparingLong

thenComparingDouble

reverseOrder

naturalOrder

nullsFirst

nullsLast

comparing

comparing

comparingInt

comparingLong

comparingDouble