跟我學Guava：基礎1.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);

        Ordering<String> naturalOrdering = Ordering.natural();        
        Ordering<Object> usingToStringOrdering = Ordering.usingToString();
        Ordering<Object> arbitraryOrdering = Ordering.arbitrary();
        
        System.out.println("naturalOrdering:"+ naturalOrdering.sortedCopy(list));     
        System.out.println("usingToStringOrdering:"+ usingToStringOrdering.sortedCopy(list));        
        System.out.println("arbitraryOrdering:"+ arbitraryOrdering.sortedCopy(list));
    }
}

　　輸出：

list:[peida, jerry, harry, eva, jhon, neron]
naturalOrdering:[eva, harry, jerry, jhon, neron, peida]
usingToStringOrdering:[eva, harry, jerry, jhon, neron, peida]
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]
true
false
naturalIntReduceOrdering:[1, 2, 3, 4, 5, 6, 7, 8, 9]
listReduce:[9, 8, 7, 6, 5, 4, 3, 2, 1]
true
true
true
true
isOrdered reverse :false
false
false
[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 :false
isOrdered 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]


針對複雜類型的比較，則可以採用ComparisonChain：

import com.google.common.collect.ComparisonChain;
import com.google.common.collect.Ordering;

public class OrderingTest {
    private static Ordering<BeanPerson> flexOrdering = new Ordering<BeanPerson>() {
        @Override
        public int compare(BeanPerson left, BeanPerson right) {
            return ComparisonChain.start().compare(left.name, right.name, Ordering.usingToString())
                    .compare(left.age, right.age, Ordering.natural().nullsLast().reverse()).result();
        }
    };

    public static void main(String[] args) {
        List<BeanPerson> plist = new ArrayList<BeanPerson>();
        plist.add(new BeanPerson("abd", 1));
        plist.add(new BeanPerson("abc", 2));
        plist.add(new BeanPerson("abc", 4));
        plist.add(new BeanPerson("abd", 3));
        System.out.println("list:" + plist);
        plist = flexOrdering.sortedCopy(plist);
        System.out.println("----------");
        for (BeanPerson bp : plist) {
            System.out.println("==" + bp.name + "," + bp.age);
        }
        System.out.println("----------");
    }
}
public class BeanPerson {
    public BeanPerson(String name, int age) {
        this.name = name;
        this.age = age;
    }
    int age;
    String name;
}

測試結果：
----------
==abc,4
==abc,2
==abd,3
==abd,1
----------

官方譯文：http://ifeve.com/google-guava-ordering/