Guava 简明教程
Guava - Ordering Class
排序可以看作是具有增强的链式功能、多种实用方法、多类型排序功能等的增强型比较器。
Class Declaration
以下是 com.google.common.collect.Ordering<T> 类的声明 −
@GwtCompatible
public abstract class Ordering<T>
extends Object
implements Comparator<T>Class Methods
Sr.No |
Method & Description |
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 视为小于所有其他值并使用此规则比较非空值的排序规则。 |
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) 等效的 Ordering。 |
31 |
<E extends T> List<E> sortedCopy(Iterable<E> elements) 返回包含按此排序规则排序的元素的可变列表；仅在可能需要进一步修改结果列表或可能包含 null 时使用此列表。 |
32 |
static Ordering<Object> usingToString() 返回通过 toString() 返回的字符串表示的自然排序顺序比较对象的排序规则。 |
Example of Ordering Class
使用任意你选择的编辑器在 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);
}
}Verify the Result
按照如下方式使用 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]