📌  相关文章
📜  Guava-订购类

📅  最后修改于: 2020-11-16 06:51:52             🧑  作者: Mango

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

类声明

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

@GwtCompatible
public abstract class Ordering
   extends Object
      implements Comparator

类方法

Sr.No Method & Description
1

static Ordering allEqual()

Returns an ordering which treats all values as equal, indicating “no ordering.” Passing this ordering to any stable sort algorithm results in no change to the order of elements.
2

static Ordering arbitrary()

Returns an arbitrary ordering over all objects, for which compare(a, b) == 0 implies a == b (identity equality).
3

int binarySearch(List sortedList, T key)

Searches sortedList for key using the binary search algorithm.
4

abstract int compare(T left, T right)

Compares its two arguments for order.
5

Ordering compound(Comparator secondaryComparator)

Returns an ordering which first uses the ordering this, but which in the event of a “tie”, then delegates to secondaryComparator.
6

static Orderingcompound(Iterable> comparators)

Returns an ordering which tries each given comparator in order until a non-zero result is found, returning that result, and returning zero only if all comparators return zero.
7

static Orderingexplicit(List valuesInOrder)

Returns an ordering that compares objects according to the order in which they appear in the given list.
8

static Orderingexplicit(T leastValue, T… remainingValuesInOrder)

Returns an ordering that compares objects according to the order in which they are given to this method.
9

static Orderingfrom(Comparator comparator)

Returns an ordering based on an existing comparator instance.
10

List greatestOf(Iterable iterable, int k)

Returns the k greatest elements of the given iterable according to this ordering, in order from greatest to least.
11

List greatestOf(Iterator iterator, int k)

Returns the k greatest elements from the given iterator according to this ordering, in order from greatest to least.
12

ImmutableList immutableSortedCopy(Iterable elements)

Returns an immutable list containing elements sorted by this ordering.
13

boolean isOrdered(Iterable iterable)

Returns true if each element in iterable after the first is greater than or equal to the element that preceded it, according to this ordering.
14

boolean isStrictlyOrdered(Iterable iterable)

Returns true if each element in iterable after the first is strictly greater than the element that preceded it, according to this ordering
15

List leastOf(Iterable iterable, int k)

Returns the k least elements of the given iterable according to this ordering, in order from least to greatest.
16

List leastOf(Iterator elements, int k)

Returns the k least elements from the given iterator according to this ordering, in order from least to greatest.
17

Ordering> lexicographical()

Returns a new ordering which sorts iterables by comparing corresponding elements pairwise until a nonzero result is found; imposes “dictionary order”.
18

E max(E a, E b)

Returns the greater of the two values according to this ordering.
19

E max(E a, E b, E c, E… rest)

Returns the greatest of the specified values according to this ordering.
20

E max(Iterable iterable)

Returns the greatest of the specified values according to this ordering.
21

E max(Iterator iterator)

Returns the greatest of the specified values according to this ordering.
22

E min(E a, E b)

Returns the lesser of the two values according to this ordering.
23

E min(E a, E b, E c, E… rest)

Returns the least of the specified values according to this ordering.
24

E min(Iterable iterable)

Returns the least of the specified values according to this ordering.
25

E min(Iterator iterator)

Returns the least of the specified values according to this ordering.
26

static Ordering natural()

Returns a serializable ordering that uses the natural order of the values.
27

Ordering nullsFirst()

Returns an ordering that treats null as less than all other values and uses this to compare non-null values.
28

Ordering nullsLast()

Returns an ordering that treats null as greater than all other values and uses this ordering to compare non-null values.
29

Ordering onResultOf(Function function)

Returns a new ordering on F which orders elements by first applying a function to them, then comparing those results using this.
30

Ordering reverse()

Returns the reverse of this ordering; the Ordering equivalent to Collections.reverseOrder(Comparator).
31

List sortedCopy(Iterable elements)

Returns a mutable list containing elements sorted by this ordering; use this only when the resulting list may need further modification, or may contain null.
32

static Ordering usingToString()

Returns an ordering that compares objects by the natural ordering of their string representations as returned by 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 numbers = new ArrayList();
      
      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 names = new ArrayList();
      
      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]