番石榴 - 订购类

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

类别声明

以下是com.google.common.collect.Ordering<T>类的声明-

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

类方法

先生编号 方法及说明
1

静态排序<Object> allEqual()

返回将所有值视为相等的排序，表示“无排序”。将此排序传递给任何稳定的排序算法不会导致元素顺序发生变化。
2

静态排序<Object>任意()

返回所有对象的任意顺序，其中compare(a, b) == 0 意味着a == b（身份相等）。
3

int binarySearch(List<?extendsT>sortedList,Tkey)

使用二分搜索算法在排序列表中搜索键。
4

抽象 int 比较（T 左，T 右）

比较其两个参数的顺序。
5

<U extends T> 排序<U> 复合(Comparator<? super U> secondaryComparator)

返回一个排序，它首先使用排序 this，但如果出现“平局”，则委托给 secondaryComparator。
6

static <T> Ordering<T> 复合（Iterable<? extends Comparator<? super T>> 比较器）

返回一个排序，该排序按顺序尝试每个给定的比较器，直到找到非零结果，返回该结果，并且仅当所有比较器返回零时才返回零。
7

静态 <T> 排序 <T> 显式(List<T> valueInOrder)

返回一个排序，该排序根据对象在给定列表中出现的顺序进行比较。
8

静态 <T> 排序 <T> 显式（T 最小值，T...剩余值InOrder）

返回一个排序，该排序根据对象提供给此方法的顺序进行比较。
9

static <T> Ordering<T> from(Comparator<T> 比较器)

返回基于现有比较器实例的排序。
10

<E 扩展 T> List<E> GreatOf(Iterable<E> iterable, int k)

根据此排序，按从最大到最小的顺序返回给定可迭代的 k 个最大元素。
11

<E 扩展 T> List<E> GreatOf(Iterator<E> 迭代器, int k)

根据此排序，按从最大到最小的顺序返回给定迭代器中的 k 个最大元素。
12

<E 扩展 T> ImmutableList<E> immutableSortedCopy(Iterable<E> 元素)

返回一个不可变列表，其中包含按此顺序排序的元素。
13

boolean isOrdered(Iterable<? extends T> iterable)

根据此顺序，如果 iterable 中第一个元素之后的每个元素都大于或等于它前面的元素，则返回 true。
14

boolean isStrictlyOrdered(Iterable<? extends T> iterable)

如果 iterable 中第一个元素之后的每个元素严格大于其前面的元素（根据此顺序），则返回 true
15

<E 扩展 T> List<E> lessOf(Iterable<E> iterable, int k)

根据此排序（从最小到最大的顺序）返回给定可迭代的 k 个最小元素。
16

<E 扩展 T> List<E> lessOf(Iterator<E> elements, int k)

根据此顺序，按从最小到最大的顺序返回给定迭代器中的 k 个最小元素。
17 号

<S 扩展 T> 排序 <Iterable<S>> 字典序()

返回一个新的排序，它通过成对比较相应的元素来对可迭代对象进行排序，直到找到非零结果；强加“字典顺序”。
18

<E 扩展 T> E max(E a, E b)

根据此顺序返回两个值中较大的一个。
19

<E 扩展 T> E max(E a, E b, E c, E... 其余)

根据此顺序返回指定值中的最大值。
20

<E 扩展 T> E max(Iterable<E> 可迭代)

根据此顺序返回指定值中的最大值。
21

<E 扩展 T> E max(Iterator<E> 迭代器)

根据此顺序返回指定值中的最大值。
22

<E 扩展 T> E min(E a, E b)

根据此顺序返回两个值中较小的一个。
23

<E 扩展 T> E min(E a, E b, E c, E... 其余)

根据此顺序返回指定值中的最小值。
24

<E 扩展 T> E min(Iterable<E> 可迭代)

根据此顺序返回指定值中的最小值。
25

<E 扩展 T> E min(Iterator<E> 迭代器)

根据此顺序返回指定值中的最小值。
26

static <C extends Comparable> Ordering<C> natural()

返回使用值的自然顺序的可序列化顺序。
27

<S 扩展 T> 排序 <S> nullsFirst()

返回一个排序，该排序将 null 视为小于所有其他值，并使用它来比较非 null 值。
28

<S 扩展 T> 排序 <S> nullsLast()

返回将 null 视为大于所有其他值的排序，并使用此排序来比较非 null 值。
29

<F> Ordering<F> onResultOf(Function<F,? extends T> function)

返回 F 上的新排序，它通过首先对元素应用函数来对元素进行排序，然后使用它比较这些结果。
30

<S 扩展 T> 排序 <S> 反向()

返回此顺序的相反顺序；Ordering 相当于 Collections.reverseOrder(Comparator)。
31

<E 扩展 T> List<E>sortedCopy(Iterable<E> 元素)

返回一个可变列表，其中包含按此顺序排序的元素；仅当结果列表可能需要进一步修改或可能包含 null 时才使用此选项。
32

静态排序 <Object> usingToString()

返回一个排序，该排序按照 toString() 返回的字符串表示形式的自然顺序来比较对象。

继承的方法

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

  • java.lang.Object

订购类别示例

使用您选择的任何编辑器（例如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: 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]