com.google.common.collect.Ordering

订购

例

assertTrue（byLengthOrdering 。反向（） 。 isOrdered（列表））;

概观

Ordering是Guava的“流畅” Comparator类，可用于构建复杂的比较器并将其应用于对象集合。

从本质上讲，Ordering实例只不过是一个特殊的Comparator 实例。Ordering简单地采用依赖于Comparator（例如Collections.max）的方法，并使它们可用作实例方法。对于额外的功率，Ordering类提供链接方法来调整和增强现有的比较器。

创建

常见的排序由静态方法提供：

方法	描述
natural()	使用Comparable类型的自然顺序。
usingToString()	通过字符串表示的字典排序来比较对象，如返回的那样toString()。

将预先存在Comparator为an Ordering就像使用一样简单 Ordering.from(Comparator)。

但是创建自定义的更常见方法Ordering是Comparator完全跳过 Ordering直接扩展抽象类：

订购< String > byLengthOrdering =  new  Ordering < String >（）{
   public  int  compare（String  left，String  right）{
     return  Ints 。比较（左。长度（），右。长度（））;
  }
};

链接

Ordering可以包装给定以获得派生的排序。一些最常用的变体包括：

方法	描述
reverse()	返回反向排序。
nullsFirst()	返回Ordering在非null元素之前对null进行排序的行为，否则与原始元素的行为相同Ordering。也可以看看nullsLast()
compound(Comparator)	返回一个Ordering使用指定Comparator的“断开关系”。
lexicographical()	返回按Ordering字典顺序排列迭代的元素。
onResultOf(Function)	返回Ordering通过将函数应用于它们然后使用原始函数比较结果来对值进行排序的值Ordering。

例如，假设你想要一个比较器...

class  Foo {
   @Nullable  String sortedBy;
  int notSortedBy;
}

...可以处理的空值sortedBy。这是在链接方法之上构建的解决方案：

订购< Foo > ordering =  订购。自然（）。nullsFirst（）。onResultOf（新 功能< 美孚，字符串 >（）{
   公共 字符串 申请（美孚 FOO）{
     返回 FOO 。 sortedBy;
  }
}）;

在阅读一连串Ordering电话时，从右到左“向后”工作。上面的Foo示例通过查找其sortedBy字段值来对实例进行sortedBy排序，首先将任何空值移动到顶部，然后通过自然字符串排序对剩余值进行排序。这种向后顺序的产生是因为每个链接调用都将前Ordering一个“包装” 成新的。

（“向后”规则的例外情况：对于呼叫链，compound从左到右阅读。为避免混淆，请避免compound将呼叫与其他链式呼叫混用。）

链接长于几个电话可能很难理解。我们建议将链接限制为大约三个调用，如上例所示。即便如此，您可能希望通过分离出中间对象（例如Function实例）来简化代码 ：

订购< Foo > ordering =  订购。自然（）。nullsFirst（）。onResultOf（sortKeyFunction）;

应用

Guava提供了许多使用排序来操作或检查值或集合的方法。我们列出了一些最受欢迎的。

方法	描述	也可以看看
greatestOf(Iterable iterable, int k)	k根据此排序，按从最大到最小的顺序返回指定iterable 的最大元素。不一定稳定。	leastOf
isOrdered(Iterable)	Iterable根据此顺序测试指定的是否为非递减顺序。	isStrictlyOrdered
sortedCopy(Iterable)	返回指定元素的排序副本作为List。	immutableSortedCopy
min(E, E)	根据此顺序返回其两个参数的最小值。如果值比较相等，则返回第一个参数。	max(E, E)
min(E, E, E, E...)	根据此顺序返回其参数的最小值。如果有多个最小值，则返回第一个值。	max(E, E, E, E...)
min(Iterable)	返回指定的最小元素Iterable。NoSuchElementException如果Iterable是空的则抛出一个。	max(Iterable)，min(Iterator)，max(Iterator)

代码

public class Test {


    public static void main(String[] args) {


        List<String> list = Lists.newArrayList();
        list.add("peida");
        list.add("jerry");
        list.add("harry");
        list.add("eva");
        list.add("jhon");
        list.add("neron");

        System.out.println("list:"+ list);


        Ordering<String> ordering = new Ordering<String>() {
            @Override
            public int compare(@Nullable String left, @Nullable String right) {
                return Ints.compare(left.length(),right.length());
            }
        };


        /**
         * 自然升序
         */
        Ordering<String> ordering1 = Ordering.natural();


        System.out.println(ordering1.sortedCopy(list));

        Ordering<String> ordering3 =   ordering1.reverse();

        //根据ordering3的排序规则，返回一个新的副本
        System.out.println(ordering3.sortedCopy(list));


        list.add("a");

        list.add(null);

        list.add(null);

        //nullsFirst  null放在最后
        System.out.println(ordering.nullsFirst().sortedCopy(list));

        //nullsLast null放在最后
        System.out.println(ordering.nullsLast().sortedCopy(list));


        System.out.println();


      //  集合里已经添加了null , 会报null异常
        System.out.println(ordering3.sortedCopy(list));

         //  集合里已经添加了null , 会报null异常
        //从大到小取出2个
        System.out.println(ordering3.greatestOf(list,2));

         //  集合里已经添加了null , 会报null异常
        //从小到大取出2个
        System.out.println(ordering3.leastOf(list,2));
    }
}

结果 （集合中已经去掉了null）

list:[peida, jerry, harry, eva, jhon, neron]
[eva, harry, jerry, jhon, neron, peida]
[peida, neron, jhon, jerry, harry, eva]
[a, eva, jhon, peida, jerry, harry, neron]
[a, eva, jhon, peida, jerry, harry, neron]

[peida, neron, jhon, jerry, harry, eva, a]
[a, eva]
[peida, neron]