模块  java.base
软件包  java.util

Interface Comparator<T>

  • 参数类型
    T - 此比较器可以比较的对象类型
    所有已知实现类:
    CollatorRuleBasedCollator
    Functional Interface:
    这是一个功能接口,因此可以用作lambda表达式或方法引用的赋值目标。

    @FunctionalInterfacepublic interface Comparator<T>
    比较函数,它对某些对象集合施加总排序 可以将比较器传递给排序方法(例如Collections.sortArrays.sort ),以便精确控制排序顺序。 比较器还可用于控制某些数据结构的顺序(例如sorted setssorted maps ),或者为没有natural ordering的对象集合提供排序。

    比较器c对一组元素S施加的排序被认为与等号一致,当且仅当c.compare(e1, e2)==0具有与e1.equals(e2)e1e2S中的S相同的布尔值时。

    当使用能够强加与equals不一致的排序的比较器来排序有序集(或有序映射)时,应该谨慎行事。 假设具有显式比较器c的有序集(或有序映射)与从集合S提取的元素(或键) S 如果cS的排序与equals不一致,则排序集(或有序映射)将表现得“奇怪”。 特别是有序集(或有序映射)将违反集合(或映射)的一般合同,其定义为equals

    例如,假设有两个元素ab ,使(a.equals(b) && c.compare(a, b) != 0)为空TreeSet ,比较器为c 第二个add操作将返回true(并且树集的大小将增加)因为ab在树集的视角中不相等,即使这与Set.add方法的规范相反。

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

    对于数学上的倾斜,即限定了施加顺序给定的比较器的关系 c上一组给定对象强加S是:

      {(x, y) such that c.compare(x, y) <= 0}. 
    此总订单的是:
      {(x, y) such that c.compare(x, y) == 0}. 
    它从合同紧跟compare ,该商数是一个等价关系 S ,并且实行排序是全序 S 当我们说cS施加的排序与equals一致时 ,我们的意思是排序的商是由对象' equals(Object)方法定义的等价关系:
      {(x, y) such that x.equals(y)}. 

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

    此界面是Java Collections Framework的成员。

    从以下版本开始:
    1.2
    另请参见:
    ComparableSerializable
    • 方法详细信息

      • compare

        int compare​(T o1,            T o2)
        比较它的两个参数的顺序。 返回负整数,零或正整数,因为第一个参数小于,等于或大于第二个参数。

        实现程序必须确保sgn(compare(x, y)) == -sgn(compare(y, x))所有xy (这意味着当且仅当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)) 一般来说,任何违反此条件的比较器都应清楚地表明这一事实。 推荐的语言是“注意:这个比较器强加了与equals不一致的排序。”

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

        参数
        o1 - 要比较的第一个对象。
        o2 - 要比较的第二个对象。
        结果
        第一个参数的负整数,零或正整数小于,等于或大于第二个参数。
        异常
        NullPointerException - 如果参数为null且此比较器不允许空参数
        ClassCastException - 如果参数的类型阻止它们被这个比较器比较。
      • equals

        boolean equals​(Object obj)
        指示某个其他对象是否“等于”此比较器。 此方法必须遵守Object.equals(Object)的总合同。 此外, 当指定的对象也是比较器并且它与此比较器施加相同的顺序时,此方法才能返回true 因此, comp1.equals(comp2)暗示sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))为每个对象引用o1o2

        请注意, 不要覆盖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 Note:
        例如,要根据长度和不区分大小写的自然顺序对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()
        返回一个比较器,它强加自然顺序的反转。

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

        参数类型
        T - 要比较的Comparable元素类型
        结果
        比较器,对 Comparable对象施加 自然顺序的反转。
        从以下版本开始:
        1.8
        另请参见:
        Comparable
      • naturalOrder

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

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

        参数类型
        T - 要比较的Comparable元素类型
        结果
        比较器,对 Comparable对象强加 自然排序
        从以下版本开始:
        1.8
        另请参见:
        Comparable
      • nullsFirst

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

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

        参数类型
        T - 要比较的元素的类型
        参数
        comparator - 用于比较非空值的 Comparator
        结果
        一个比较器, null视为小于非null,并将非空对象与提供的 Comparator进行比较。
        从以下版本开始:
        1.8
      • nullsLast

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

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

        参数类型
        T - 要比较的元素的类型
        参数
        comparator - 用于比较非空值的 Comparator
        结果
        一个比较器, null视为大于非null,并将非空对象与提供的 Comparator进行比较。
        从以下版本开始:
        1.8
      • comparing

        static <T,​U> Comparator<T> comparing​(Function<? super T,​? extends U> keyExtractor,                                           Comparator<? super U> keyComparator)
        接受从类型T中提取排序键的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
        从以下版本开始:
        1.8
      • comparing

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

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

        API Note:
        例如,要获取Comparator ,用它们的姓氏比较Person对象,
           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排序键的T ,并返回按该排序键进行比较的Comparator<T>

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

        参数类型
        T - 要比较的元素类型
        参数
        keyExtractor - 用于提取整数排序键的函数
        结果
        比较器,通过提取的密钥进行比较
        异常
        NullPointerException - 如果参数为null
        从以下版本开始:
        1.8
        另请参见:
        comparing(Function)
      • comparingLong

        static <T> Comparator<T> comparingLong​(ToLongFunction<? super T> keyExtractor)
        接受从类型T中提取long排序键的T ,并返回按该排序键进行比较的Comparator<T>

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

        参数类型
        T - 要比较的元素的类型
        参数
        keyExtractor - 用于提取长排序键的函数
        结果
        比较器,通过提取的密钥进行比较
        异常
        NullPointerException - 如果参数为null
        从以下版本开始:
        1.8
        另请参见:
        comparing(Function)
      • comparingDouble

        static <T> Comparator<T> comparingDouble​(ToDoubleFunction<? super T> keyExtractor)
        接受从类型T中提取double排序键的T ,并返回按该排序键进行比较的Comparator<T>

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

        参数类型
        T - 要比较的元素类型
        参数
        keyExtractor - 用于提取双排序键的函数
        结果
        比较器,通过提取的密钥进行比较
        异常
        NullPointerException - 如果参数为null
        从以下版本开始:
        1.8
        另请参见:
        comparing(Function)