Guava学习笔记 第4个记录(Ordering犀利的比较器)

    Ordering是Guava类库提供的一个犀利强大的比较器工具，Guava的Ordering和JDK Comparator相比功能更强。它很是容易扩展，能够轻松构造复杂的comparator，而后用在容器的比较、排序等操做中。

    本质上来讲，Ordering 实例无非就是一个特殊的Comparator 实例。Ordering只是须要依赖于一个比较器（例如，Collections.max）的方法，并使其可做为实例方法。另外，Ordering提供了链式方法调用和增强现有的比较器。

下面咱们看看Ordering中的一些具体方法和简单的使用实例。

常见的静态方法：

• natural()：使用Comparable类型的天然顺序， 例如：整数从小到大，字符串是按字典顺序;

• usingToString() ：使用toString()返回的字符串按字典顺序进行排序；

• arbitrary() ：返回一个全部对象的任意顺序， 即compare(a, b) == 0 就是 a == b (identity equality)。 自己的排序是没有任何含义， 可是在VM的生命周期是一个常量。

简单实例：

import java.util.List;
import org.junit.Test;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;

public class OrderingTest {

    @Test
    public void testStaticOrdering(){
        List<String> list = Lists.newArrayList();
        list.add("peida");
        list.add("jerry");
        list.add("harry");
        list.add("eva");
        list.add("jhon");
        list.add("neron");
        
        System.out.println("list:"+ list);
        //list:[peida, jerry, harry, eva, jhon, neron]
        Ordering<String> naturalOrdering = Ordering.natural();        
        Ordering<Object> usingToStringOrdering = Ordering.usingToString();
        Ordering<Object> arbitraryOrdering = Ordering.arbitrary();
        
        System.out.println("naturalOrdering:"+ naturalOrdering.sortedCopy(list));     
        //naturalOrdering:[eva, harry, jerry, jhon, neron, peida]
        System.out.println("usingToStringOrdering:"+ usingToStringOrdering.sortedCopy(list));          //usingToStringOrdering:[eva, harry, jerry, jhon, neron, peida]
        System.out.println("arbitraryOrdering:"+ arbitraryOrdering.sortedCopy(list));
        //arbitraryOrdering:[neron, harry, eva, jerry, peida, jhon]
    }
}

操做方法：

• reverse(): 返回与当前Ordering相反的排序:

• nullsFirst(): 返回一个将null放在non-null元素以前的Ordering，其余的和原始的Ordering同样；

• nullsLast()：返回一个将null放在non-null元素以后的Ordering，其余的和原始的Ordering同样；
  

• compound(Comparator)：返回一个使用Comparator的Ordering，Comparator做为第二排序元素，例如对bug列表进行排序，先根据bug的级别，再根据优先级进行排序；

• lexicographical()：返回一个按照字典元素迭代的Ordering；

• onResultOf(Function)：将function应用在各个元素上以后, 在使用原始ordering进行排序；
  

• greatestOf(Iterable iterable, int k)：返回指定的第k个可迭代的最大的元素，按照这个从最大到最小的顺序。是不稳定的。
  

• leastOf(Iterable<E> iterable,int k)：返回指定的第k个可迭代的最小的元素，按照这个从最小到最大的顺序。是不稳定的。
  

• isOrdered(Iterable)：是否有序，Iterable不能少于2个元素。
  

• isStrictlyOrdered(Iterable)：是否严格有序。请注意，Iterable不能少于两个元素。
  

• sortedCopy(Iterable)：返回指定的元素做为一个列表的排序副本。
  

package com.peidasoft.guava.base;import java.util.List;import org.junit.Test;import com.google.common.collect.ImmutableList;import com.google.common.collect.Lists;import com.google.common.collect.Ordering;public class OrderingTest {
    
    @Test    public void testOrdering(){
        List<String> list = Lists.newArrayList();
        list.add("peida");
        list.add("jerry");
        list.add("harry");
        list.add("eva");
        list.add("jhon");
        list.add("neron");
        
        System.out.println("list:"+ list);
        
        Ordering<String> naturalOrdering = Ordering.natural();
        System.out.println("naturalOrdering:"+ naturalOrdering.sortedCopy(list));    

        List<Integer> listReduce= Lists.newArrayList();        for(int i=9;i>0;i--){
            listReduce.add(i);
        }
        
        List<Integer> listtest= Lists.newArrayList();
        listtest.add(1);
        listtest.add(1);
        listtest.add(1);
        listtest.add(2);
        
        
        Ordering<Integer> naturalIntReduceOrdering = Ordering.natural();
        
        System.out.println("listtest:"+ listtest);
        System.out.println(naturalIntReduceOrdering.isOrdered(listtest));
        System.out.println(naturalIntReduceOrdering.isStrictlyOrdered(listtest));
        
        
        System.out.println("naturalIntReduceOrdering:"+ naturalIntReduceOrdering.sortedCopy(listReduce));
        System.out.println("listReduce:"+ listReduce);
        
        
        System.out.println(naturalIntReduceOrdering.isOrdered(naturalIntReduceOrdering.sortedCopy(listReduce)));
        System.out.println(naturalIntReduceOrdering.isStrictlyOrdered(naturalIntReduceOrdering.sortedCopy(listReduce)));
        

        Ordering<String> natural = Ordering.natural();
              
        List<String> abc = ImmutableList.of("a", "b", "c");
        System.out.println(natural.isOrdered(abc));
        System.out.println(natural.isStrictlyOrdered(abc));
        
        System.out.println("isOrdered reverse :"+ natural.reverse().isOrdered(abc));
 
        List<String> cba = ImmutableList.of("c", "b", "a");
        System.out.println(natural.isOrdered(cba));
        System.out.println(natural.isStrictlyOrdered(cba));
        System.out.println(cba = natural.sortedCopy(cba));
        
        System.out.println("max:"+natural.max(cba));
        System.out.println("min:"+natural.min(cba));
        
        System.out.println("leastOf:"+natural.leastOf(cba, 2));
        System.out.println("naturalOrdering:"+ naturalOrdering.sortedCopy(list));    
        System.out.println("leastOf list:"+naturalOrdering.leastOf(list, 3));
        System.out.println("greatestOf:"+naturalOrdering.greatestOf(list, 3));
        System.out.println("reverse list :"+ naturalOrdering.reverse().sortedCopy(list));    
        System.out.println("isOrdered list :"+ naturalOrdering.isOrdered(list));
        System.out.println("isOrdered list :"+ naturalOrdering.reverse().isOrdered(list));
        list.add(null);
        System.out.println(" add null list:"+list);
        System.out.println("nullsFirst list :"+ naturalOrdering.nullsFirst().sortedCopy(list));
        System.out.println("nullsLast list :"+ naturalOrdering.nullsLast().sortedCopy(list));
    }

}//============输出==============list:[peida, jerry, harry, eva, jhon, neron]
naturalOrdering:[eva, harry, jerry, jhon, neron, peida]
listtest:[1, 1, 1, 2]truefalsenaturalIntReduceOrdering:[1, 2, 3, 4, 5, 6, 7, 8, 9]
listReduce:[9, 8, 7, 6, 5, 4, 3, 2, 1]truetruetruetrueisOrdered reverse :falsefalsefalse[a, b, c]
max:c
min:a
leastOf:[a, b]
naturalOrdering:[eva, harry, jerry, jhon, neron, peida]
leastOf list:[eva, harry, jerry]
greatestOf:[peida, neron, jhon]
reverse list :[peida, neron, jhon, jerry, harry, eva]
isOrdered list :falseisOrdered list :false
 add null list:[peida, jerry, harry, eva, jhon, neron, null]
nullsFirst list :[null, eva, harry, jerry, jhon, neron, peida]
nullsLast list :[eva, harry, jerry, jhon, neron, peida, null]