Guava - 订购类

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

类声明

以下是 com.google.common.collect.Ordering< T> class :

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

类方法

Sr.No	方法&说明
1	static Ordering< Object> allEqual() 返回将所有值视为相等的排序，表示"无排序".将此排序传递给任何稳定排序算法都不会导致元素顺序发生变化.
2	static Ordering<Object> arbitrary() 返回所有对象的任意排序，compare(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延伸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()返回的字符串表示的自然顺序来比较对象.

方法继承

此类继承以下类中的方法 :

• java.lang.Object

订购类示例

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

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]