Guava教學 » Guava Ordering類

Guava Ordering類

Ordering(排序)可以被看作是一個豐富的比較具有增強功能的連結，多個實用方法，多型別排序功能等。

類宣告

以下是com.google.common.collect.Ordering<T>類的宣告：

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

類方法

S.N. 方法及說明
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)
搜尋排序列表使用鍵的二進位制搜尋演算法。
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)
返回根據這個順序給出疊代，為了從最大到最小的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 <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

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]