Guava Ordering类

精华

小牛编辑

183浏览

2023-03-14

1 什么是Guava Ordering类

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

2 Guava Ordering类的语法

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

3 Guava Ordering类的方法

方法	描述
static Ordering<Object> allEqual()	返回将所有值视为相等的排序，指示“无排序”。将此排序传递给任何稳定的排序算法不会改变元素的顺序。
static Ordering<Object> arbitrary()	返回对所有对象的任意排序，其中 compare(a, b) == 0 意味着 a == b（相等）。
int binarySearch(List<? extends T> sortedList, T key)	使用二分搜索算法在 sortedList 中搜索key。
abstract int compare(T left, T right)	比较它的两个参数的顺序。
<U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator)	返回一个排序，它首先使用排序 this，但在“平局”的情况下，然后委托给 secondaryComparator。
static <T> Ordering<T> compound(Iterable<? extends Comparator<? super T>> comparators)	返回一个顺序，它按顺序尝试每个给定的比较器，直到找到非零结果，返回该结果，并且仅当所有比较器都返回零时才返回零。
static <T> Ordering<T> explicit(List<T> valuesInOrder)	返回根据对象在给定列表中出现的顺序比较对象的排序。
static <T> Ordering<T> explicit(T leastValue, T... remainingValuesInOrder)	返回一个排序，该排序根据对象被赋予此方法的顺序来比较对象。
static <T> Ordering<T> from(Comparator<T> comparator)	返回基于现有比较器实例的排序。
<E extends T> List<E> greatestOf(Iterable<E> iterable, int k)	根据此顺序返回给定可迭代对象的 k 个最大元素，从最大到最小。
<E extends T> List<E> greatestOf(Iterator<E> iterator, int k)	根据此顺序从给定的迭代器返回 k 个最大的元素，从最大到最小的顺序。
<E extends T> ImmutableList<E> immutableSortedCopy(Iterable<E> elements)	返回包含按此顺序排序的元素的不可变列表。
boolean isOrdered(Iterable<? extends T> iterable)	根据此顺序，如果第一个可迭代元素之后的每个元素都大于或等于它之前的元素，则返回 true。
boolean isStrictlyOrdered(Iterable<? extends T> iterable)	如果第一个元素之后的每个可迭代元素严格大于它之前的元素，则根据此顺序返回 true
<E extends T> List<E> leastOf(Iterable<E> iterable, int k)	根据此顺序返回给定可迭代对象的 k 个最少元素，从最小到最大。
<S extends T> Ordering<Iterable<S>> lexicographical()	根据此顺序返回给定迭代器中最少的 k 个元素，从最小到最大。
<E extends T> E max(E a, E b)	返回一个新的排序，它通过成对比较相应的元素来对可迭代对象进行排序，直到找到非零结果；强加“字典顺序”。
<E extends T> E max(E a, E b, E c, E... rest)	根据此顺序返回两个值中较大的一个。
<E extends T> E max(Iterable<E> iterable)	根据此顺序返回指定值中的最大值。
<E extends T> E max(Iterator<E> iterator)	根据此顺序返回指定值中的最大值。
<E extends T> E min(E a, E b)	根据此顺序返回指定值中的最小值。
<E extends T> E min(E a, E b, E c, E... rest)	根据此顺序返回两个值中的较小者。
<E extends T> E min(Iterable<E> iterable)	根据此顺序返回指定值中的最小值。
<E extends T> E min(Iterator<E> iterator)	根据此顺序返回指定值中的最小值。
static <C extends Comparable> Ordering<C> natural()	返回使用值的自然顺序的可序列化排序。
<S extends T> Ordering<S> nullsFirst()	返回将 null 视为小于所有其他值的排序，并使用它来比较非 null 值。
<S extends T> Ordering<S> nullsLast()	返回将 null 视为大于所有其他值的排序，并使用此排序来比较非 null 值。
<F> Ordering<F> onResultOf(Function<F,? extends T> function)	在 F 上返回一个新的排序，它通过首先对元素应用函数来对元素进行排序，然后使用 this 比较这些结果。
<S extends T> Ordering<S> reverse()	返回此顺序的相反顺序；Ordering 等价于 Collections.reverseOrder(Comparator)。
<E extends T> List<E> sortedCopy(Iterable<E> elements)	返回包含按此顺序排序的元素的可变列表；仅当结果列表可能需要进一步修改或可能包含空值时才使用它。
static Ordering<Object> usingToString()	返回一个排序，该排序通过 toString() 返回的字符串表示的自然排序来比较对象。

5 Guava Ordering类的例子

让我们看一个简单的Guava Ordering类示例。

package cn.xnip;

import com.google.common.collect.Ordering;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

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);
   }
}

输出结果为：