Guava – Ordering 类
Ordering可以被看作是一个丰富的比较器，具有增强的连锁功能、多种实用方法、多类型的排序能力等.
Ordering 类声明
以下是com.google.common.collection.Order
@GwtCompatiblepublic abstract class Ordering<T> extends Object implements Comparator<T>
Ordering 类函数
| 序号 | 函数和描述 |
|---|---|
| 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)<br/> 返回一个排序，首先使用这个排序，但是如果出现 “平局”，则委托给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) 根据这个排序，按照从大到小的顺序，返回给定的iterable中最大的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) 如果在iterable中第一个元素之后的每个元素都大于或等于前面的元素，根据这个排序，返回true. |
| 14 | boolean isStrictlyOrdered(Iterable<? extends T> iterable) 如果在iterable中第一个元素之后的每个元素都严格大于前面的元素，根据这个排序，返回true |
| 15 | <E extends T> List<E> leastOf(Iterable<E> iterable, int k) 根据这个排序，按照从少到多的顺序，返回给定的iterable中最小的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)<br/> 根据这个排序，返回指定值中的最小值. |
| 25 | <E extends T> E min(Iterator<E> iterator) 根据这个排序，返回指定值中的最小值. |
| 26 | static <C extends Comparable> Ordering<C> natural() 返回一个可序列化的排序，该排序使用数值的自然顺序. |
| 27 | <S extends T> Ordering<S> nullsFirst() 返回一个将空值视为小于所有其他值的排序，并以此来比较非空值. |
| 28 | <S extends T> Ordering<S> nullsLast() 返回一个将空值视为大于所有其他值的排序，并使用此排序来比较非空值. |
| 29 | <F> Ordering<F> onResultOf(Function<F,? extends T> function) 返回F上的一个新的排序，它通过首先对元素应用一个函数来排序，然后用这个比较这些结果. |
| 30 | <S extends T> Ordering<S> reverse() 返回该排序的反向；相当于Collections.reverseOrder(Comparator)的排序. |
| 31 | <E extends T> List<E> sortedCopy(Iterable<E> elements) 返回一个包含按此排序的元素的可变列表；只有在产生的列表可能需要进一步修改，或者可能包含null时才使用此方法. |
| 32 | static Ordering<Object> usingToString() 返回一个排序，按照toString()返回的它们的字符串表示的自然排序来比较对象. |
Ordering 类继承
该类继承了以下类的方法 −
java.lang.ObjectOrdering 类示例
在C:/ >Guava中使用你选择的任何编辑器创建以下java程序.
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: trueMinimum: 2Maximum: 53Reverse: [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]
