Guava进修笔记：Ordering锋利的斗劲器

添加时间:2013-6-25 点击量:

　　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]

原来，再大的房子，再大的床，没有相爱的人陪伴，都只是冰冷的物质。而如果身边有爱人陪伴，即使房子小，床小，也觉得无关紧要，因为这些物质上面有了爱的温度，成了家的元素。—— 何珞《婚房》#书摘#

分享到：

相关文章

按版本划分

按功能划分

企业管理软件

Guava进修笔记：Ordering锋利的斗劲器