Guava - 排序類

上一頁
下一頁

排序可以被視為一個增強型比較器，具有增強的連結功能、多個實用程式方法、多型別排序功能等。

類宣告

以下是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)

返回一個首先使用排序this的排序，但在出現“平局”時，則委託給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視為小於所有其他值的排序，並使用此排序來比較非null值。
28

<S extends T> Ordering<S> nullsLast()

返回一個將null視為大於所有其他值的排序，並使用此排序來比較非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]
列印頁面
上一頁
下一頁
廣告

© . All rights reserved.