Ordering是Guava類庫提供的一個犀利強大的比較器工具，Guava的Ordering和JDK Comparator相比功能更強。它非常容易擴充套件，可以輕鬆構造複雜的comparator，然後用在容器的比較、排序等操作中。

　　本質上來說，Ordering 例項無非就是一個特殊的Comparator 例項。Ordering只是需要依賴於一個比較器（例如，Collections.max）的方法，並使其可作為例項方法。另外，Ordering提供了鏈式方法呼叫和加強現有的比較器。

Comparator, Comparable區別

/*
     * Comparator, Comparable區別
     * <p>
     * 1.comparable是通用的介面，使用者可以實現它來完成自己特定的比較，
     *      而comparator可以看成一種演算法的實現,在需要容器集合 collection需要比較功能的時候，來指定這個比較器。
     * 2.一個類實現了Camparable介面表明這個類的物件之間是可以相互比較的。
     *      如果用數學語言描述的話就是這個類的物件組成的集合中存在一個全序。這樣，這個類物件組成的集合就可以使用Sort方法排序了。
     * 3.而Comparator的作用有兩個：
     * 　a，如果類的設計師沒有考慮到Compare的問題而沒有實現Comparable介面，可以通過Comparator來實現比較演算法進行排序
     * 　b，可以更加靈活實現排序規則，為了使用不同的排序標準做準備，比如：升序、降序，或者將來想通過類的其他欄位進行排序
     *
     * 例如：在對List 排序時候預設使用comparable的compareTo(Object o)方法
     *      但在比較某個物件下的屬性時候，我們可以自定義一個Comparator的compare(Object o1, Object o2)方法比較器進行比較
     *      Collections 中的 public static <T> void sort(List<T> list, Comparator<? super T> c) 方法
     *
     */
    private class ComparableAndComparatorDistinction implements Comparator, Comparable {

        /*
         * 重寫Comparable中的方法
         */
        @Override
        public int compareTo(Object o) {
            return 0;
        }

        /*
         * 重寫Comparator中的方法
         */
        @Override
        public int compare(Object o1, Object o2) {
            return 0;
        }
    }
 

Ordering犀利的比較器

程式碼演示

package com.framework_technology.commons.google.base;

import com.google.common.base.Function;
import com.google.common.base.Objects;
import com.google.common.collect.ComparisonChain;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.List;

/**
 * 部分Object 方法
 * <p>
 * Ordering犀利的比較器
 *
 * @author wei.Li by 14-8-27.
 */
public class ObjectMethodsAndOrdering {

    /**
     * 當一個物件中的欄位可以為null時，實現Object.equals方法會很痛苦，因為不得不分別對它們進行null檢查。
     * 使用Objects.equal幫助你執行null敏感的equals判斷，從而避免丟擲NullPointerException。
     * <p>
     * 注意：JDK7引入的Objects類提供了一樣的方法Objects.equals。
     */
    private static void objectsEqual() {
        Objects.equal("a", "a"); // returns true
        Objects.equal(null, "a"); // returns false
        Objects.equal("a", null); // returns false
        Objects.equal(null, null); // returns true

        Objects.hashCode("a", "b");//
    }

    /**
     * 用物件的所有欄位作雜湊[hash]運算應當更簡單。
     * Guava的Objects.hashCode(Object...)會對傳入的欄位序列計算出合理的、順序敏感的雜湊值。
     * 你可以使用Objects.hashCode(field1, field2, …, fieldn)來代替手動計算雜湊值。
     * <p>
     * 注意：JDK7引入的Objects類提供了一樣的方法Objects.hash(Object...)
     */
    private static void objectsHashCode() {
        Objects.equal("a", "a"); // returns true
        Objects.equal(null, "a"); // returns false
        Objects.equal("a", null); // returns false
        Objects.equal(null, null); // returns true

        Objects.hashCode("a", "b");//
    }


    /**
     * 實現一個比較器[Comparator]
     * JDK 與 Guava的實現的不同
     */
    private class Person2compareToTest implements Comparable<Person2compareToTest> {
        private String lastName;
        private String firstName;
        private int zipCode;

        /**
         * jdk 方式的比較
         *
         * @param other
         * @return
         */
        @Override
        public int compareTo(Person2compareToTest other) {
            int cmp = lastName.compareTo(other.lastName);
            if (cmp != 0) {
                return cmp;
            }
            cmp = firstName.compareTo(other.firstName);
            if (cmp != 0) {
                return cmp;
            }
            return Integer.compare(zipCode, other.zipCode);
        }

        /**
         * Guava的實現
         * <p>
         * ComparisonChain執行一種懶比較：它執行比較操作直至發現非零的結果，在那之後的比較輸入將被忽略。
         *
         * @param that 比較物件
         * @return 比較結果
         * @see #compareTo(Person2compareToTest)
         */
        public int compareToByComparisonChain(Person2compareToTest that) {
            return ComparisonChain.start()
                    .compare(this.lastName, that.lastName)
                    .compare(this.firstName, that.firstName)
                    .compare(this.zipCode, that.zipCode, Ordering.natural().nullsLast())
                    .result();
        }
    }


    /**
     * Ordering犀利的比較器演示
     * <p>
     * jdk8也實現了部分
     *
     * @see java.util.Comparators
     */
    private static class OrderTest implements Comparable<OrderTest> {

        private int id;
        private String name;

        public static final OrderTest[] ORDER_TESTS = new OrderTest[]{
                new OrderTest(1, "yiwa")
                , new OrderTest(11, "yiwa")
                , new OrderTest(2, "erwa")
                , new OrderTest(3, "sanwa")
                , new OrderTest(4, "siwa")
                , new OrderTest(5, "wuwa")
                , new OrderTest(5, "wuwa")
                , new OrderTest(6, null)
        };

        OrderTest(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public int compareTo(OrderTest that) {
            return ComparisonChain.start()
                    // .compare(this.id, that.id)
                    .compare(this, that, getOrdering())
                    .result()
                    ;
        }

        /**
         * 構建Ordering
         */
        private static Ordering<OrderTest> getOrdering() {

            return Ordering
                    .natural()
                    .nullsFirst()
                            //返回按String 排序的Comparable
                            //當閱讀鏈式呼叫產生的排序器時，應該從後往前讀。
                            // 下面的例子中，排序器首先呼叫apply方法獲取name值，並把name為null的元素都放到最前面，然後把剩下的元素按name進行自然排序。
                            // 之所以要從後往前讀，是因為每次鏈式呼叫都是用後面的方法包裝了前面的排序器。
                    .onResultOf(new Function<OrderTest, Comparable>() {
                        @Override
                        public Comparable apply(OrderTest input) {
                            return input.name;
                        }
                    })
                    // .leastOf(Arrays.asList(ORDER_TESTS),2)
                    ;
        }


        /**
         * 運用選擇器進行一些計算
         */
        private static void appleOrdering() {
            Ordering ordering = getOrdering();
            List<OrderTest> orderTestList
                    = Lists.newArrayList(ORDER_TESTS);

            //判斷可迭代物件是否已按排序器排序：允許有排序值相等的元素。
            boolean orderingOrdered = ordering.isOrdered(orderTestList);
            LOGGER.info("isOrdered          : <{}>", orderingOrdered);

            //判斷可迭代物件是否已按排序器嚴格排序：不允許有排序值相等的元素。
            boolean orderingStrictlyOrdered = ordering.isStrictlyOrdered(orderTestList);
            LOGGER.info("isStrictlyOrdered  : <{}>", orderingStrictlyOrdered);

            //返回指定的元素作為一個列表的排序副本。immutableSortedCopy返回不可變的排序副本
            // LOGGER.info("sortedCopy  : <{}>", ordering.sortedCopy(orderTestList));

            //最大的2元素
            LOGGER.info("greatestOf 2 index : <{}>", ordering.greatestOf(orderTestList, 4));

            //獲取最大值，迭代比較大小後返回
            LOGGER.info("orderTestList max  : <{}>", ordering.max(orderTestList));
        }

        @Override
        public String toString() {
            return "OrderTest{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }

    }

    private static final org.slf4j.Logger LOGGER
            = LoggerFactory.getLogger(Optional_.class);

    public static void main(String[] args) {

        Arrays.sort(OrderTest.ORDER_TESTS);
        LOGGER.info("---------- ORDER_TESTS after sort start ----------");
        for (OrderTest orderTest : OrderTest.ORDER_TESTS) {
            LOGGER.info("<{}>", orderTest);
        }
        LOGGER.info("---------- ORDER_TESTS after sort end   ----------");

        LOGGER.info("\n---------- Apple Ordering start ----------");
        OrderTest.appleOrdering();
        LOGGER.info("---------- Apple Ordering end   ----------");

        /* main 函式執行結果
        ---------- ORDER_TESTS after sort start ----------
<OrderTest{id=6, name='null'}>
<OrderTest{id=2, name='erwa'}>
<OrderTest{id=3, name='sanwa'}>
<OrderTest{id=4, name='siwa'}>
<OrderTest{id=5, name='wuwa'}>
<OrderTest{id=5, name='wuwa'}>
<OrderTest{id=1, name='yiwa'}>
<OrderTest{id=11, name='yiwa'}>
---------- ORDER_TESTS after sort end   ----------

---------- Apple Ordering start ----------
isOrdered          : <true>
isStrictlyOrdered  : <false>
greatestOf 2 index : <[OrderTest{id=1, name='yiwa'}, OrderTest{id=11, name='yiwa'},
                      OrderTest{id=5, name='wuwa'}, OrderTest{id=5, name='wuwa'}]>
orderTestList max  : <OrderTest{id=1, name='yiwa'}>
---------- Apple Ordering end   ----------

         */
    }
}