开源项目

相关文章

更多

最近更新

更多

Guava Ordering类处理排序功能

2019-04-23 23:02|来源: 网路

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

类声明

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

@GwtCompatiblepublic abstract class Ordering<T>
   extends Object
      implements Comparator<T>

类方法

S.N. 方法及说明
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)
搜索排序列表使用键的二进制搜索算法。
4 abstract int compare(T left, T right)
比较两个参数的顺序。
5 <U extends T> Ordering<U> compound(Comparator<? super U> secondaryComparator)
返回首先使用排序这一点,但它排序中的“tie”,然后委托给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)。
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]


相关问答

更多

为什么Guava不为小的ImmutableLists使用专门的类?(Why does Guava not use specialized classes for small ImmutableLists?)

你能帮我理解这里涉及的权衡吗? 这是一个权衡: 性能 - 不分配临时数组可以节省成本。 但是,人们需要进行一些广泛的代码分析和基准测试来量化这种节省。 (我怀疑在大多数应用程序中它都是微不足道的。请阅读@Voo提供的这个链接 !) 可读性 - 拥有一堆额外的重载会使javadoc混乱。 可维护性 - 有一堆重载是以不需要临时对象的方式实现的,这需要大量的复制/粘贴编程,这使得将来的代码维护更加困难。 实用程序 - 这些重载的使用频率是多少? 我希望答案“很少”。 字节码占用空间 - 这些额外的重载 ...

如何从Guava的List中获取max()元素(How to get max() element from List in Guava)

Ordering<Item> o = new Ordering<Item>() { @Override public int compare(Item left, Item right) { return Ints.compare(left.price, right.price); } }; return o.max(list); 它的效率一样高:它遍历列表的项目,并返回具有最大价格的第一个项目:O(n)。 Ordering<Item> o = new O ...

Java对Guava TreeBasedTable进行排序(Java Sort a Guava TreeBasedTable)

如果您只是创建一个使用不同比较器对象创建的新TreeBasedTable,然后通过公共putAll方法将原始文件复制到其中,那该怎么办? 每个元素的put将采用log(N),因此总时间应为N log(n),这大约是重新排序所需的时间。 How about if you just create a new TreeBasedTable, created with a different comparator object, and then copy the original into it via ...

是否有可能将Guava的ForwardingListIterator和PeekingIterator结合起来?(Is it possible to combine Guava's ForwardingListIterator with a PeekingIterator?)

将一个新的“窥视”概念引入到一个已经很容易在两个方向上滚动的迭代器的价值在哪里? 如果你真的想要它,你可以实现两个简单的静态助手: public static <T> T peekNext(ListIterator<T> iterator) { T next = iterator.next(); iterator.previous(); return next; } public static <T> T peekPrevious(ListIterator<T> iterator) ...

来自Guava或Java枚举的ImmutableSet(ImmutableSet from Guava or Java enum)

我可以通过使用Java枚举来获得相同的结果吗? 是的你可以。 你试过了吗? FYI还有专门版本的ImmutableSet ,它持有枚举的常量 - Sets.immutableEnumSet (在内部它使用EnumSet )。 一些例子(解释Wiki例子): public class Test { enum Color { RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE; } static class Baz { ImmutableS ...

番石榴的IntervalTree(IntervalTree in Guava)

Guava没有提供这个,尽管你可以通过找到给定点之前和之后的第一个范围来在RangeSet之上构建这样的东西。 但一般来说,除了类型的比较排序之外,Guava Range对距离,度量或任何其他内容一无所知 。 他们不知道10比15更接近11 。 Guava doesn't provide this, though you might be able to build such a thing on top of a RangeSet by finding the first range befor ...

Guava ValueGraph的简单示例(Simple example of Guava ValueGraph)

Guava wiki提供了以下使用ValueGraph示例: MutableValueGraph<Integer, Double> weightedGraph = ValueGraphBuilder.directed().build(); weightedGraph.addNode(1); weightedGraph.putEdgeValue(2, 3, 1.5); // also adds nodes 2 and 3 if not already present weightedGraph.p ...

不兼容的库版本selenium / guava(Incompatible library version selenium / guava)

因为你对com.google.guava:guava:23.3 org.seleniumhq.selenium:selenium-java:3.0.1依赖性com.google.guava:guava:23.3使用org.seleniumhq.selenium:selenium-java:3.0.1可能会让你在十字路口。 但是Selenium发行说明清楚地提到了以下番石榴依赖性: Selenium v2.49.0 :Bump guava到19版 Selenium v3.1.0 :需要更新最新的番石 ...

检测使用哪种Guava版本?(Detect which Guava version is used? [duplicate])

您可以从guava.jar中的META-INF /下的文件中获取版本字符串。 在运行时,您需要使用适当的ClassLoader实例来加载所需的META-INF /文件。 您可以使用Guava的Resources实用程序类直接加载具有唯一名称的资源,也可以使用$someGuavaClassName.class.getClassLoader().getResources(String)在多个jar文件中遍历具有相同名称的资源。 如果你使用后者,那么你将需要使用someGuavaClassName将在你 ...

使用guava AbstractScheduledService(Using guava AbstractScheduledService)

AbstractScheduledServiced实现Service 。 Service接口描述了生命周期方法,包括startAsync 。 ServiceState枚举文字包含有关其含义的文档。 处于NEW状态的服务(刚刚创建): 处于此状态的服务处于非活动状态。 它做的工作量极少,占用资源极少。 要使服务执行某些有用的操作,您必须将其转换为RUNNING状态 此状态下的服务正在运行。 这就是为什么你必须在它做任何事之前启动服务的原因。 我还建议不要从构造函数中调用startAsync,而是从创 ...