Guava Ordering类

可以将Ordering视为一个增强的比较器，具有增强的链接功能、多种实用方法、多类型排序能力等。

类声明

下面是 com.google.common.collect.Ordering <T> 类的声明 –

@GwtCompatible
public abstract class Ordering<T>
   extends Object
      implements Comparator<T>

类方法

序号	方法与描述
1	`static Ordering <Object> allEqual()` 返回一个将所有值看作相等的排序方法，表示”无排序”。将该排序方法传递给任何稳定排序算法都不会改变元素的顺序。
2	`static Ordering <Object> arbitrary()` 返回一个对所有对象进行任意排序的排序方法，其中`compare(a, b) == 0`表示`a == b`（相等性）。
3	`int binarySearch(List <? extends T> sortedList, T key)` 使用二分搜索算法在sortedList中搜索key。
4	`abstract int compare(T left, T right)` 比较其两个参数的顺序。
5	`<U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator)` 返回一个排序，首先使用这个排序，但在“绑定”情况下委托给secondaryComparator。
6	`static <T> Ordering<T> compound(Iterable<? extends Comparator<? super T>> comparators)` 返回一个排序，按顺序尝试每个给定的比较器，直到找到非零结果，返回该结果，并且仅当所有比较器返回零时返回零。
7	`static <T> Ordering<T> explicit(List<T> valuesInOrder)`返回一个明确的排序，该排序按照给定的顺序对值进行排序。返回一个根据对象在给定列表中出现的顺序进行比较的排序方式。
8	`static <T> Ordering<T> explicit(T leastValue, T... remainingValuesInOrder)` 返回一个根据对象被传递给该方法的顺序进行比较的排序方式。
9	`static <T> Ordering<T> from(Comparator<T> comparator)` 返回基于现有比较器实例的排序方式。
10	`<E extends T> List<E> greatestOf(Iterable<E> iterable, int k)` 根据此排序方式，返回给定可迭代对象中最大的k个元素，按从最大到最小的顺序。
11	`<E extends T> List<E> greatestOf(Iterator<E> iterator, int k)` 根据此排序方式，从给定的迭代器中返回k个最大的元素，按照从最大到最小的顺序。
12	`<E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> elements)` 返回一个按照此排序方式排序的不可变列表，其中包含元素。
13	`boolean isOrdered(Iterable <? extends T> iterable)` 根据此排序方式，如果可迭代对象中每个元素在前一个元素之后大于或等于它，则返回true。
14	`boolean isStrictlyOrdered(Iterable <? extends T> iterable)`如果可迭代对象中每个元素在第一个元素之后都严格大于前面的元素，则返回true，根据此排序方式
15	`<E extends T> List<E> leastOf(Iterable<E> iterable, int k)` 根据此排序方式，返回给定可迭代对象的最小的k个元素，按从最小到最大的顺序排列。
16	`<E extends T> List<E> leastOf(Iterator<E> elements, int k)` 根据此排序方式，从给定迭代器中返回最小的k个元素，按从最小到最大的顺序排列。
17	`<S extends T> Ordering<Iterable<S>> lexicographical()` 返回一个新的排序方式，通过逐个比较相应的元素对直到发现非零结果；施加“字典顺序”。
18	`<E extends T> E max(E a, E b)` 根据该排序方法返回两个值中较大的值。
19	`<E extends T> E max(E a, E b, E c, E... rest)` 根据该排序方法返回指定值中最大的值。
20	`<E extends T> E max(Iterable<E> iterable)` 根据该排序方法返回指定值中最大的值。
21	`<E extends T> E max(Iterator<E> iterator)` 根据该排序方法返回指定值中最大的值。
22	`<E extends T> E min(E a, E b)` 返回两个值中较小的值。根据这个排序规则，返回两个值中较小的一个。
23	`<E extends T> E min(E a, E b, E c, E... rest)` 根据这个排序规则，返回指定值中最小的一个。
24	`<E extends T> E min(Iterable<E> iterable)` 根据这个排序规则，返回指定值中最小的一个。
25	`<E extends T> E min(Iterator<E> iterator)` 根据这个排序规则，返回指定值中最小的一个。
26	`static <C extends Comparable> Ordering<C> natural()` 返回一个可序列化的排序规则，使用值的自然顺序。
27	`~~Ordering ~~nullsFirst()` 返回一个将null视为小于所有其他值的顺序，并使用此顺序来比较非null值的顺序。
28	`~~Ordering ~~nullsLast()` 返回一个将null视为大于所有其他值的顺序，然后使用此顺序来比较非null值的顺序。
29	`Ordering onResultOf(Function function)` 返回一个基于F的新顺序，通过首先将一个函数应用到元素上，然后使用此顺序来比较结果。
30	`~~Ordering ~~reverse()` 返回此排序的反向排序；等效于 Collections.reverseOrder(Comparator) 的 Ordering。
31	`＜E extends T＞ List＜E＞ sortedCopy(Iterable＜E＞ elements)` 返回包含根据此排序进行排序的元素的可变列表；仅在结果列表可能需要进一步修改或可能包含 null 时使用此功能。
32	`static Ordering＜Object＞ usingToString()` 返回通过对象的字符串表示的自然顺序进行比较的排序，该字符串表示由 toString() 方法返回。

继承的方法

该类从以下类继承方法 –

java.lang.Object

Ordering的示例

使用您选择的任意编辑器创建以下的java程序，例如 C:/ > Guava.

GuavaTester.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import com.google.common.collect.Ordering;

public class GuavaTester {
   public static void main(String args[]) {
      List<Integer> numbers = new ArrayList<Integer>();

      numbers.add(new Integer(5));
      numbers.add(new Integer(2));
      numbers.add(new Integer(15));
      numbers.add(new Integer(51));
      numbers.add(new Integer(53));
      numbers.add(new Integer(35));
      numbers.add(new Integer(45));
      numbers.add(new Integer(32));
      numbers.add(new Integer(43));
      numbers.add(new Integer(16));

      Ordering ordering = Ordering.natural();
      System.out.println("Input List: ");
      System.out.println(numbers);      

      Collections.sort(numbers,ordering );
      System.out.println("Sorted List: ");
      System.out.println(numbers);

      System.out.println("======================");
      System.out.println("List is sorted: " + ordering.isOrdered(numbers));
      System.out.println("Minimum: " + ordering.min(numbers));
      System.out.println("Maximum: " + ordering.max(numbers));

      Collections.sort(numbers,ordering.reverse());
      System.out.println("Reverse: " + numbers);

      numbers.add(null);
      System.out.println("Null added to Sorted List: ");
      System.out.println(numbers);      

      Collections.sort(numbers,ordering.nullsFirst());
      System.out.println("Null first Sorted List: ");
      System.out.println(numbers);
      System.out.println("======================");

      List<String> names = new ArrayList<String>();

      names.add("Ram");
      names.add("Shyam");
      names.add("Mohan");
      names.add("Sohan");
      names.add("Ramesh");
      names.add("Suresh");
      names.add("Naresh");
      names.add("Mahesh");
      names.add(null);
      names.add("Vikas");
      names.add("Deepak");

      System.out.println("Another List: ");
      System.out.println(names);

      Collections.sort(names,ordering.nullsFirst().reverse());
      System.out.println("Null first then reverse sorted list: ");
      System.out.println(names);
   }
}

验证结果

使用 javac 编译器编译该类，如下所示−

C:\Guava>javac GuavaTester.java

现在运行GuavaTester来查看结果。

C:\Guava>java GuavaTester

查看结果。

Input List: 
[5, 2, 15, 51, 53, 35, 45, 32, 43, 16]
Sorted List: 
[2, 5, 15, 16, 32, 35, 43, 45, 51, 53]
======================
List is sorted: true
Minimum: 2
Maximum: 53
Reverse: [53, 51, 45, 43, 35, 32, 16, 15, 5, 2]
Null added to Sorted List: 
[53, 51, 45, 43, 35, 32, 16, 15, 5, 2, null]
Null first Sorted List: 
[null, 2, 5, 15, 16, 32, 35, 43, 45, 51, 53]
======================
Another List: 
[Ram, Shyam, Mohan, Sohan, Ramesh, Suresh, Naresh, Mahesh, null, Vikas, Deepak]
Null first then reverse sorted list: 
[Vikas, Suresh, Sohan, Shyam, Ramesh, Ram, Naresh, Mohan, Mahesh, Deepak, null]