Comparator (Java Platform SE 8 )

参数类型

T -可以通过该比较器比较对象的类型

所有已知实现类：

Collator， RuleBasedCollator

Functional Interface:

这是一个功能接口，因此可以作为赋值的目标一个lambda表达式或方法参考。
```
@FunctionalInterface
public interface Comparator<T>
```
一个比较函数，这对一些对象的集合，对总序。比较器可以通过某种方法（如 Collections.sort或 Arrays.sort）允许在排序顺序的精确控制。比较器也可以用来控制特定的数据结构顺序（如 sorted sets或 sorted maps），或提供的对象不集合排序有 natural ordering。
订购的一组元素S比较器c强加说是符合等于当且仅当c.compare(e1, e2)==0具有相同的布尔值为S每e1和e2 e1.equals(e2)。

当使用一个能够施加与等于不一致的排序的比较器来订购一个排序的集合（或排序的Map）时，应谨慎使用。假设一个有序集合（或排序图）有一个明确的比较c使用元素（或键）从一组S得出。如果订购c强加在S是不平等的，排序的集合（或排序图）将表现“奇怪”。特别是有序集合（或排序图）将违反一般合同的集合（或Map），这是从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），指（x，y）< = 0 }。
```
这个总的顺序是：商
```
{（x，y），指（x，y）= = 0 }。
```
紧随其后，从 compare商是 S一个等价关系合同，这是一个总序 S强加订购。当我们说订购 c强加在 S是符合等于，意味着我们的订货商由物体 equals(Object)方法定义的等价关系（S）：
```
{（x，y），x.equals（y）}。
```
不像Comparable，比较器可以允许空参数的比较，同时保持一个等价关系的要求。

该接口的 Java Collections Framework成员。
从以下版本开始：

一点二

另请参见：

Comparable， Serializable

方法摘要

所有方法静态方法接口方法抽象方法 Default Methods
Modifier and Type	Method and 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<T>`比较的排序关键字使用指定的 `Comparator`。
`static <T> Comparator<T>`	`comparingDouble(ToDoubleFunction<? super T> keyExtractor)` 接受这一类型 `T`提取物一 `double`排序键的功能，并返回一个 `Comparator<T>`比较的排序关键字。
`static <T> Comparator<T>`	`comparingInt(ToIntFunction<? super T> keyExtractor)` 接受这一类型的 `int`提取物 `T`排序键的功能，并返回一个 `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`要小于非空。
`static <T> Comparator<T>`	`nullsLast(Comparator<? super T> comparator)` 返回一个空的友好比较器认为 `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`排序关键字功能字典序比较。

- 方法详细信息
  - compare
```
int compare(T o1,
            T o2)
```
    比较其两个顺序的参数。返回一个负整数、零或一个正整数作为第一个参数小于、等于或大于第二个参数。
    在前面描述的符号，sgn(表达)指定数学符号函数，其定义为返回一个-1，0，或1根据是否表达值为负，零或正。
    
    实现者必须确保所有的x和y sgn(compare(x, y)) == -sgn(compare(y, x))。（这意味着compare(x, y)必须抛出一个异常，如果compare(y, x)抛出一个异常。）
    
    实现者也必须确保关系是可传递的：((compare(x, y)>0) && (compare(y, z)>0))意味着compare(x, z)>0。
    
    最后，作者必须保证compare(x, y)==0意味着所有z sgn(compare(x, z))==sgn(compare(y, z))。
    
    这是一般的情况，但不严格要求(compare(x, y)==0) == (x.equals(y))。一般来说，任何违反此条件比较清楚地表明这一事实。推荐语是“注意：此比较器施加的顺序，不符合平等的。”
    
    参数
    
    o1要比较的第一个对象。
    
    o2要比第二对象。
    
    结果
    
    一个负整数，零，或一个正整数作为第一个参数小于，等于或大于第二个。
    
    异常
    
    NullPointerException -如果一个参数为null，这比较不允许null参数
    
    ClassCastException如果参数的类型，防止该比较器的比较。
  - equals
```
boolean equals(Object obj)
```
    指示是否有其他对象“等于”这个比较器。这种方法必须服从总承包 Object.equals(Object)。此外，该方法可以指定对象是否是一个比较器，它规定相同的顺序返回 true只有这个比较器。因此， comp1.equals(comp2)意味着每一个对象的引用 o1和 o2 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))。
    请注意，这是总是安全不覆盖Object.equals(Object)。然而，重写此方法，在某些情况下，允许程序以确定两个比较器施加相同的以提高性能。
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj -参考对象的比较。
    
    结果
    
    true只有指定的对象也是一个比较器，它对同一订购这个比较器。
    
    另请参见：
    
    Object.equals(Object)， Object.hashCode()
  - reversed
```
default Comparator<T> reversed()
```
    返回一个对这个比较器的反向排序的比较器。
    
    结果
    
    一个对这个比较器的反向排序的比较器。
    
    从以下版本开始：
    
    一点八
  - thenComparing
```
default Comparator<T> thenComparing(Comparator<? super T> other)
```
    返回一个与另一个比较器的字典序比较。如果这 Comparator认为两元素相等，即 compare(a, b) == 0， other是用来确定订单。
    如果指定的比较器也可序列化序列化返回的比较器。
    API Note:
    例如，排序基于长度然后以自然顺序的 String收集，比较可以用下面的代码，
    Comparator<String> cmp = Comparator.comparingInt(String::length) .thenComparing(String.CASE_INSENSITIVE_ORDER);
    参数
    
    other -时要使用这个比较器比较两个对象相等的其他比较。
    
    结果
    
    一个字典序比较器组成的这个和其他的比较
    
    异常
    
    NullPointerException -如果参数为空。
    
    从以下版本开始：
    
    一点八
  - 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。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    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 -如果参数为空。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    comparing(Function)， thenComparing(Comparator)
  - thenComparingInt
```
default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor)
```
    返回一个具有提取 int排序关键字功能字典序比较。
    
    实现要求：
    
    此默认实现的行为如果 thenComparing(comparingInt(keyExtractor))。
    
    参数
    
    keyExtractor -用于提取整数排序键的功能
    
    结果
    
    一个字典序比较由本然后 int排序关键字
    
    异常
    
    NullPointerException -如果参数为空。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    comparingInt(ToIntFunction)， thenComparing(Comparator)
  - thenComparingLong
```
default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor)
```
    返回一个具有提取 long排序关键字功能字典序比较。
    
    实现要求：
    
    此默认实现的行为如果 thenComparing(comparingLong(keyExtractor))。
    
    参数
    
    keyExtractor -用于提取长排序键的功能
    
    结果
    
    一个字典序比较由本然后 long排序关键字
    
    异常
    
    NullPointerException -如果参数为空。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    comparingLong(ToLongFunction)， thenComparing(Comparator)
  - thenComparingDouble
```
default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)
```
    返回一个具有提取 double排序关键字功能字典序比较。
    
    实现要求：
    
    此默认实现的行为如果 thenComparing(comparingDouble(keyExtractor))。
    
    参数
    
    keyExtractor -用于提取双排序键的功能
    
    结果
    
    一个字典序比较由本然后 double排序关键字
    
    异常
    
    NullPointerException -如果参数为空。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    comparingDouble(ToDoubleFunction)， thenComparing(Comparator)
  - reverseOrder
```
static <T extends Comparable<? super T>> Comparator<T> reverseOrder()
```
    返回一个比较器，该比较器将自然排序的反向。
    返回的比较器可序列化和投NullPointerException比较时，null。
    
    参数类型
    
    T -元是比较 Comparable型
    
    结果
    
    一个比较器， Comparable对象征收的自然排序反向。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    Comparable
  - naturalOrder
```
static <T extends Comparable<? super T>> Comparator<T> naturalOrder()
```
    返回一个比较器，比较 Comparable对象自然秩序。
    返回的比较器可序列化和投NullPointerException比较时，null。
    
    参数类型
    
    T -元是比较 Comparable型
    
    结果
    
    一个比较器， Comparable对象征收的自然排序。
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    Comparable
  - nullsFirst
```
static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator)
```
    返回一个空的友好比较器认为 null要小于非空。当双方都 null，他们被认为是平等的。如果都是非空的，指定的 Comparator是用来确定订单。如果指定的比较器 null，然后返回的比较器认为所有非空值相等。
    如果指定的比较器，比较器是序列化序列化返回。
    
    参数类型
    
    T -被比较元素的类型
    
    参数
    
    comparator -一种比较非空值 Comparator
    
    结果
    
    认为 null要小于非零比较器，比较非空对象提供的 Comparator。
    
    从以下版本开始：
    
    一点八
  - nullsLast
```
static <T> Comparator<T> nullsLast(Comparator<? super T> comparator)
```
    返回一个空的友好比较器认为 null要大于非空。当双方都 null，他们被认为是平等的。如果都是非空的，指定的 Comparator是用来确定订单。如果指定的比较器 null，然后返回的比较器认为所有非空值相等。
    如果指定的比较器，比较器是序列化序列化返回。
    
    参数类型
    
    T -被比较元素的类型
    
    参数
    
    comparator - Comparator比较非空值
    
    结果
    
    认为 null要大于非零比较器，比较非空对象提供的 Comparator。
    
    从以下版本开始：
    
    一点八
  - comparing
```
static <T,U> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor,
                                     Comparator<? super U> keyComparator)
```
    接受一个提取从类型 T排序关键字的功能，并返回一个 Comparator<T>比较的排序关键字使用指定的 Comparator。
    如果指定的功能和比较器都序列化返回的比较器可序列化。
    API Note:
    例如，获得 Comparator比较 Person对象按姓氏忽略大小写的差异，
    Comparator<Person> cmp = Comparator.comparing( Person::getLastName, String.CASE_INSENSITIVE_ORDER);
    参数类型
    
    T -被比较元素的类型
    
    U -排序键的类型
    
    参数
    
    keyExtractor -用于提取排序键的功能
    
    keyComparator -用来比较排序键的 Comparator
    
    结果
    
    一个比较器比较所提取的关键使用指定的 Comparator
    
    异常
    
    NullPointerException -如果任一参数为null
    
    从以下版本开始：
    
    一点八
  - comparing
```
static <T,U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor)
```
    接受这一类型 T提取物一 Comparable排序键的功能，并返回一个 Comparator<T>比较的排序关键字。
    如果指定的函数也返回序列化序列化比较器。
    API Note:
    例如，获得 Comparator比较 Person对象的姓名，
    Comparator<Person> byLastName = Comparator.comparing(Person::getLastName);
    参数类型
    
    T -被比较元素的类型
    
    U的 Comparable排序关键字的类型
    
    参数
    
    keyExtractor -用于提取 Comparable排序键的功能
    
    结果
    
    比较由提取的键的比较
    
    异常
    
    NullPointerException -如果参数为空
    
    从以下版本开始：
    
    一点八
  - comparingInt
```
static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor)
```
    接受这一类型的 int提取物 T排序键的功能，并返回一个 Comparator<T>比较的排序关键字。
    如果指定的函数也返回序列化序列化比较器。
    
    参数类型
    
    T -被比较元素的类型
    
    参数
    
    keyExtractor -用于提取整数排序键的功能
    
    结果
    
    比较由提取的键的比较
    
    异常
    
    NullPointerException -如果参数为空
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    comparing(Function)
  - comparingLong
```
static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor)
```
    接受这一类型 T提取物一 long排序键的功能，并返回一个 Comparator<T>比较的排序关键字。
    如果指定的函数也返回序列化序列化比较器。
    
    参数类型
    
    T -被比较元素的类型
    
    参数
    
    keyExtractor -用于提取长排序键的功能
    
    结果
    
    比较由提取的键的比较
    
    异常
    
    NullPointerException -如果参数为空
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    comparing(Function)
  - comparingDouble
```
static <T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor)
```
    接受这一类型 T提取物一 double排序键的功能，并返回一个 Comparator<T>比较的排序关键字。
    如果指定的函数也返回序列化序列化比较器。
    
    参数类型
    
    T -被比较元素的类型
    
    参数
    
    keyExtractor -用于提取双排序键的功能
    
    结果
    
    比较由提取的键的比较
    
    异常
    
    NullPointerException -如果参数为空
    
    从以下版本开始：
    
    一点八
    
    另请参见：
    
    comparing(Function)

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Interface Comparator<T>

方法摘要

方法详细信息

compare

equals

reversed

thenComparing

thenComparing

thenComparing

thenComparingInt

thenComparingLong

thenComparingDouble

reverseOrder

naturalOrder

nullsFirst

nullsLast

comparing

comparing

comparingInt

comparingLong

comparingDouble