zoukankan      html  css  js  c++  java
  • Guava学习笔记(4):Ordering犀利的比较器

    转自:http://www.cnblogs.com/peida/p/Guava_Ordering.html

    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]
  • 相关阅读:
    input表单元素的默认padding不一致问题
    【转】iOS25彩票 幸运转盘
    微分起源
    转载--微分几何为何必然兴起?
    前缀和?or差分序列?
    noip2014 小结
    2019艾瑞(北京)年度高峰会议-数能驱动新变量
    MSF初体验
    s实现指定时间自动跳转到某个页面
    css实现居中
  • 原文地址:https://www.cnblogs.com/mengrennwpu/p/5107952.html
Copyright © 2011-2022 走看看