Most visited

Recently visited

Results for

Added in API level 1
Summary: Methods | [Expand All]

Comparator

public interface Comparator

java.util.Comparator<T>
Known Indirect Subclasses

比较函数，对某些对象集合施加全部排序 。 可以将比较器传递给排序方法（如Collections.sort或Arrays.sort ），以便精确控制排序顺序。 比较器也可用于控制某些数据结构（如sorted sets或sorted maps ）的顺序，或者为没有natural ordering的对象集合提供排序。

通过比较 c上一组元素 S的确定的顺序对被认为是 与等号当且仅当 c.compare(e1, e2)==0具有用于 S每 e1和 e2相同布尔值 e1.equals(e2) 一致 。

当使用比较器能够强加与equals不一致的比较器来命令一个有序集合（或排序映射）时，应该谨慎。 假设使用明确的比较器c的有序集合（或有序映射）与从集合S绘制的元素（或键） 一起使用 。 如果在S上的c强加的顺序与等号不一致，那么排序后的集合（或排序后的映射）将表现“奇怪”。 特别是有序集合（或排序映射）将违反集合（或映射）的一般合同，该集合按照equals定义。

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

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

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

       {(x, y) such that c.compare(x, y) <= 0}.
The quotient for this total order is: 
       {(x, y) such that c.compare(x, y) == 0}.
It follows immediately from the contract for compare that the quotient is an equivalence relation on S, and that the imposed ordering is a total order on S. When we say that the ordering imposed by c on S is consistent with equals, we mean that the quotient for the ordering is the equivalence relation defined by the objects' equals(Object) method(s): 
     {(x, y) such that x.equals(y)}.

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

该界面是 Java Collections Framework的成员。

也可以看看：

Summary

Public methods
abstract int compare(T o1, T o2)

比较它的两个命令。
static <T, U> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)

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

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

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

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

接受从 long类型中提取 long排序键的 T ，并返回一个 Comparator<T> ，该排序键用该排序键进行比较。
abstract 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大于非空的友好的比较器。
static <T extends Comparable<? super T>> Comparator<T> reverseOrder()

返回一个强制 自然顺序反转的比较器。
default Comparator<T> reversed()

返回一个比较器，强制该比较器的反向排序。
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进行比较的 Comparator 。
default Comparator<T> thenComparing(Comparator<? super T> other)

用另一个比较器返回词典顺序比较器。
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排序键的函数。

Public methods

compare

Added in API level 1 
int compare (T o1, 
                T o2)

比较它的两个命令。 由于第一个参数小于，等于或大于第二个参数，因此返回负整数，零或正整数。

在前面的描述中，符号 sgn( ) 表达式表示数学 符号函数，其定义根据 表达式的值是否为负，零或正返回的 -1一个 ，0，或 1。

实现程序必须确保sgn(compare(x, y)) == -sgn(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暗示 sgn(compare(x, z))==sgn(compare(y, z))全部为 z 。

通常情况下，但并非严格要求(compare(x, y)==0) == (x.equals(y)) 。 一般而言，任何违反此条件的比较器都应明确指出这一事实。 推荐的语言是“注意：这个比较器强加与等号不一致的排序”。

Parameters
o1 T: the first object to be compared.
o2 T: the second object to be compared.
Returns
int a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
Throws
NullPointerException if an argument is null and this comparator does not permit null arguments
ClassCastException if the arguments' types prevent them from being compared by this comparator.

comparing

Added in API level 24 
Comparator<T> comparing (Function<? super T, ? extends U> keyExtractor, 
                Comparator<? super U> keyComparator)

接受从类型 T提取排序键的 T ，并返回 Comparator<T> ，该排序键使用指定的 Comparator通过该排序键进行比较。

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

API Note:
  • For example, to obtain a Comparator that compares Person objects by their last name ignoring case differences, 
    Comparator<Person> cmp = Comparator.comparing(
             Person::getLastName,
             String.CASE_INSENSITIVE_ORDER);
Parameters
keyExtractor Function: the function used to extract the sort key
keyComparator Comparator: the Comparator used to compare the sort key
Returns
Comparator<T> a comparator that compares by an extracted key using the specified Comparator
Throws
NullPointerException if either argument is null

comparing

Added in API level 24 
Comparator<T> comparing (Function<? super T, ? extends U> keyExtractor)

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

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

API Note:
  • For example, to obtain a Comparator that compares Person objects by their last name, 
    Comparator<Person> byLastName = Comparator.comparing(Person::getLastName);
Parameters
keyExtractor Function: the function used to extract the Comparable sort key
Returns
Comparator<T> a comparator that compares by an extracted key
Throws
NullPointerException if the argument is null

comparingDouble

Added in API level 24 
Comparator<T> comparingDouble (ToDoubleFunction<? super T> keyExtractor)

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

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

Parameters
keyExtractor ToDoubleFunction: the function used to extract the double sort key
Returns
Comparator<T> a comparator that compares by an extracted key
Throws
NullPointerException if the argument is null

也可以看看：

comparingInt

Added in API level 24 
Comparator<T> comparingInt (ToIntFunction<? super T> keyExtractor)

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

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

Parameters
keyExtractor ToIntFunction: the function used to extract the integer sort key
Returns
Comparator<T> a comparator that compares by an extracted key
Throws
NullPointerException if the argument is null

也可以看看：

comparingLong

Added in API level 24 
Comparator<T> comparingLong (ToLongFunction<? super T> keyExtractor)

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

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

Parameters
keyExtractor ToLongFunction: the function used to extract the long sort key
Returns
Comparator<T> a comparator that compares by an extracted key
Throws
NullPointerException if the argument is null

也可以看看：

equals

Added in API level 1 
boolean equals (Object obj)

指示某个其他对象是否“等于”此比较器。 该方法必须遵守equals(Object)的一般合同。 另外， 只有当指定的对象也是一个比较器时，此方法才可以返回true，并且它与此比较器的顺序相同。 因此， comp1.equals(comp2)意味着sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))的每个对象的参考o1 o2和。

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

Parameters
obj Object: the reference object with which to compare.
Returns
boolean true only if the specified object is also a comparator and it imposes the same ordering as this comparator.

也可以看看：

naturalOrder

Added in API level 24 
Comparator<T> naturalOrder ()

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

返回的比较器是可序列化，并引发 NullPointerException比较时 null 。

Returns
Comparator<T> a comparator that imposes the natural ordering on Comparable objects.

也可以看看：

nullsFirst

Added in API level 24 
Comparator<T> nullsFirst (Comparator<? super T> comparator)

返回一个空值友好的比较器，它认为null小于非空值。 当两者都是null ，它们被认为是相等的。 如果两者都非空，则使用指定的Comparator来确定订单。 如果指定的比较器是null ，那么返回的比较器认为所有非空值都相等。

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

Parameters
comparator Comparator: a Comparator for comparing non-null values
Returns
Comparator<T> a comparator that considers null to be less than non-null, and compares non-null objects with the supplied Comparator.

nullsLast

Added in API level 24 
Comparator<T> nullsLast (Comparator<? super T> comparator)

返回一个空值友好的比较器，它认为null大于非空值。 当两者都是null ，它们被认为是平等的。 如果两者都非空，则使用指定的Comparator来确定订单。 如果指定的比较器是null ，则返回的比较器将认为所有非空值相等。

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

Parameters
comparator Comparator: a Comparator for comparing non-null values
Returns
Comparator<T> a comparator that considers null to be greater than non-null, and compares non-null objects with the supplied Comparator.

reverseOrder

Added in API level 24 
Comparator<T> reverseOrder ()

返回一个强制 自然顺序反转的比较器。

返回的比较器是可序列化，并引发 NullPointerException比较时 null 。

Returns
Comparator<T> a comparator that imposes the reverse of the natural ordering on Comparable objects.

也可以看看：

reversed

Added in API level 24 
Comparator<T> reversed ()

返回一个比较器，强制该比较器的反向排序。

Returns
Comparator<T> a comparator that imposes the reverse ordering of this comparator.

thenComparing

Added in API level 24 
Comparator<T> thenComparing (Function<? super T, ? extends U> keyExtractor)

返回一个字典顺序比较器，其中包含一个提取 Comparable排序键的函数。

实现要求：
  • This default implementation behaves as if thenComparing(comparing(keyExtractor)).
Parameters
keyExtractor Function: the function used to extract the Comparable sort key
Returns
Comparator<T> a lexicographic-order comparator composed of this and then the Comparable sort key.
Throws
NullPointerException if the argument is null.

也可以看看：

thenComparing

Added in API level 24 
Comparator<T> thenComparing (Function<? super T, ? extends U> keyExtractor, 
                Comparator<? super U> keyComparator)

返回一个字典顺序比较器，其中包含一个函数，用于提取要与给定的 Comparator进行比较的 Comparator 。

实现要求：
  • This default implementation behaves as if thenComparing(comparing(keyExtractor, cmp)).
Parameters
keyExtractor Function: the function used to extract the sort key
keyComparator Comparator: the Comparator used to compare the sort key
Returns
Comparator<T> a lexicographic-order comparator composed of this comparator and then comparing on the key extracted by the keyExtractor function
Throws
NullPointerException if either argument is null.

也可以看看：

thenComparing

Added in API level 24 
Comparator<T> thenComparing (Comparator<? super T> other)

用另一个比较器返回词典顺序比较器。 如果此Comparator认为两个元件相等，即compare(a, b) == 0 ， other被用来确定顺序。

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

API Note:
  • For example, to sort a collection of String based on the length and then case-insensitive natural ordering, the comparator can be composed using following code, 
    Comparator<String> cmp = Comparator.comparingInt(String::length)
             .thenComparing(String.CASE_INSENSITIVE_ORDER);
Parameters
other Comparator: the other comparator to be used when this comparator compares two objects that are equal.
Returns
Comparator<T> a lexicographic-order comparator composed of this and then the other comparator
Throws
NullPointerException if the argument is null.

thenComparingDouble

Added in API level 24 
Comparator<T> thenComparingDouble (ToDoubleFunction<? super T> keyExtractor)

使用提取 double排序键的函数返回字典顺序比较器。

实现要求：
  • This default implementation behaves as if thenComparing(comparingDouble(keyExtractor)).
Parameters
keyExtractor ToDoubleFunction: the function used to extract the double sort key
Returns
Comparator<T> a lexicographic-order comparator composed of this and then the double sort key
Throws
NullPointerException if the argument is null.

也可以看看：

thenComparingInt

Added in API level 24 
Comparator<T> thenComparingInt (ToIntFunction<? super T> keyExtractor)

返回一个字典顺序比较器，其中包含一个提取 int排序关键字的函数。

实现要求：
  • This default implementation behaves as if thenComparing(comparingInt(keyExtractor)).
Parameters
keyExtractor ToIntFunction: the function used to extract the integer sort key
Returns
Comparator<T> a lexicographic-order comparator composed of this and then the int sort key
Throws
NullPointerException if the argument is null.

也可以看看：

thenComparingLong

Added in API level 24 
Comparator<T> thenComparingLong (ToLongFunction<? super T> keyExtractor)

返回一个字典顺序比较器，其中包含一个提取 long排序键的函数。

实现要求：
  • This default implementation behaves as if thenComparing(comparingLong(keyExtractor)).
Parameters
keyExtractor ToLongFunction: the function used to extract the long sort key
Returns
Comparator<T> a lexicographic-order comparator composed of this and then the long sort key
Throws
NullPointerException if the argument is null.

也可以看看：

Android开发手册

Hooray!