1. WIKI教程
2. 学习guava
3. guava - 订购类( Ordering Class)

guava - 订购类( Ordering Class)

订购可以看作是一个丰富的比较器，具有增强的链接功能，多种实用方法，多种类型的排序功能等。

Class 声明 (Class Declaration)

以下是com.google.common.collect.Ordering《T》类的声明 -

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

Class Methods

Sr.No	方法和描述
1	static Ordering《Object》 allEqual() 返回将所有值视为相等的排序，表示“无排序”。 将此排序传递给任何稳定排序算法都不会导致元素顺序发生变化。
2	static Ordering《Object》 arbitrary() 返回所有对象的任意排序，比较（a，b）== 0表示== b（标识相等）。
3	int binarySearch(List《? extends T》 sortedList, T key) 使用二进制搜索算法在sortedList中搜索密钥。
4	abstract int compare(T left, T right) 比较它的两个参数的顺序。
5	《U extends T》 Ordering《U》 compound(Comparator《? super U》 secondaryComparator) 返回首先使用这个排序的排序，但是如果出现“tie”，则委托给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) 根据此顺序，如果第一个元素之后的每个元素大于或等于前面的元素，则返回true。
14	boolean isStrictlyOrdered(Iterable《? extends T》 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) 根据此顺序返回指定值中的最小值。
25	《E extends T》 E min(Iterator《E》 iterator) 根据此顺序返回指定值中的最小值。
26	static 《C extends Comparable》 Ordering《C》 natural() 返回使用值的自然顺序的可序列化排序。
27	《S extends T》 Ordering《S》 nullsFirst() 返回将null视为小于所有其他值的排序，并使用它来比较非空值。
28	《S extends T》 Ordering《S》 nullsLast() 返回将null视为大于所有其他值的排序，并使用此排序来比较非空值。
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（）返回的字符串表示的自然顺序来比较对象。

方法继承 (Methods Inherited)

该类继承以下类中的方法 -

• java.lang.Object

订购类示例

使用您选择的任何编辑器在C:/》 Guava.创建以下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]