本文共 5646 字，大约阅读时间需要 18 分钟。

Guava全文介绍地址:Google Guava

这次主要介绍是的是com.google.common.collect.Ordering.Ordering是一个比较器,通过额外的方法来支持常见的操作。这是一个Java“丰富”版本的Comparator,在同样的意义上,FluentIterable也用来丰富Iterable

1、Ordering介绍

像其他好用的类型,有三种方法推荐:methods for acquiring, chaining和using.

1. Acquiring 获取Ordering的一般方法： 1)相比直接实现Comparator，实现Ordering并实现compare(T, T) 2)通过已经存在的Comparator实例，使用from(Comparator)方法 3)通过Ordering的原生方法, Ordering.natural() 2. Chaining 你可以使用链式方法获得一个修改版本的Ordering,包括: 1)reverse() 2)compound(Comparator) 3)onResultOf(Function) 4)nullsFirst() / nullsLast() 3. Using 最后,使用Ordering一个比较器是必须的,或使它的一些特殊的操作,如: 1)immutableSortedCopy(java.lang.Iterable) 2)isOrdered(java.lang.Iterable

2、明白组合式的Ordering

像下面的例子复杂的链式序可以挑战的理解。

Ordering
   
     ordering =       Ordering.natural()           .nullsFirst()           .onResultOf(getBarFunction)           .nullsLast();
   

注意,每个链接方法返回一个新的Ordering实例是由前面的实例,但有机会采取行动支持实例的值将离开之前。因此,它通常倒顺看Ordering表达式有助于理解(就是从后向前看)。例如,当上面的Ordering被调用时:

1)首先,如果只有一个Foo是null,null值被视为更大

2)接下来,getBarFunction传递非空的Foo值(我们从现在起将比较Bar值) 3)接下来,如果只有一个Bar的值为空,空值被视为较小 4)最后,使用自然排序的结果(即Bar.compareTo(Bar)返回)

reverse()是一个有些不同。当你通过链阅读向后遇到一个reverse请求,向后继续直到确定结果,然后反向的结果。

3、Order的用法

1、prepare Data

1) City.java

@Builderpublic class City {    private String name;    private String zipCode;    private int population;    private double averageRainfall;    private Climate climate;```}

2) CityByPopulation

public class CityByPopulation implements Comparator
   
     {
       @Override    public int compare(City city1, City city2) {        return Ints.compare(city1.getPopulation(), city2.getPopulation());    }}
   

3) CityByRainfall

public class CityByRainfall implements Comparator
   
     {
       @Override    public int compare(City city1, City city2) {           return Doubles.compare(city1.getAverageRainfall(), city2.getAverageRainfall());    }}
   

4) OrderingTest

public class OrderingTest {    private Ordering
   
     numberOrdering = new Ordering
    
     () {        @Override        public int compare(Integer left, Integer right) {            return left.compareTo(right);        }    };    private CityByPopulation cityByPopulation = new CityByPopulation();    private CityByRainfall cityByRainfall = new CityByRainfall();    private City.Builder cityBuilder = new City.Builder();}
    
   

2、Get Greatest

@Test    public void testGetGreatestOf(){        List
   
     numbers = Lists.newArrayList(1,2,3,500000000,19,5,100,3000);        List
    
      top3 = numberOrdering.greatestOf(numbers,3);        List
     
       expected = Lists.newArrayList(500000000,3000,100);        assertThat(expected,is(top3));    }
     
    
   

3、Get Least

@Test    public void testGetLeastOf(){        List
   
     numbers = Lists.newArrayList(1,500000000,19,4,5,100,3000,2);        List
    
      bottom3 = numberOrdering.leastOf(numbers,3);        List
     
       expected = Lists.newArrayList(1,2,4);        assertThat(expected,is(bottom3));    }
     
    
   

4、Get Max

@Test    public void testGetMax(){        List
   
     numbers = Lists.newArrayList(1,500000000,19,4,5,100,3000,2);        assertThat(numberOrdering.max(numbers),is(500000000));    }
   

5、Get Min

@Test    public void testGetMin(){        List
   
     numbers = Lists.newArrayList(10,500000000,19,4,5,100,3000,2);        assertThat(numberOrdering.min(numbers),is(2));    }
   

6、Reverse Sort

@Test    public void testReverseSort(){      City city1 = cityBuilder.population(100000).build();      City city2 = cityBuilder.population(250000).build();      City city3 = cityBuilder.population(350000).build();      List
   
     cities = Lists.newArrayList(city3,city2,city1);      Ordering
    
      cityOrdering = Ordering.from(cityByPopulation);      Collections.sort(cities,cityOrdering);      //In natural sorting order      assertThat(cities.get(0),is(city1));      Collections.sort(cities,cityOrdering.reverse());      assertThat(cities.get(0),is(city3));    }
    
   

7、Secondary Sort

public void testSecondarySort(){        City city1 = cityBuilder.population(100000).averageRainfall(55.0).build();        City city2 = cityBuilder.population(100000).averageRainfall(45.0).build();        City city3 = cityBuilder.population(100000).averageRainfall(33.8).build();        List
   
     cities = Lists.newArrayList(city1,city2,city3);        Ordering
    
      secondaryOrdering = Ordering.from(cityByPopulation).compound(cityByRainfall);        Collections.sort(cities,secondaryOrdering);        assertThat(cities.get(0),is(city3));    }
    
   

8、Sort Null First

@Test    public void testSortNullFirst(){        City city1 = cityBuilder.population(100000).averageRainfall(55.0).build();        City city2 = cityBuilder.population(100000).averageRainfall(45.0).build();        City city3 = cityBuilder.population(100000).averageRainfall(33.8).build();        List
   
     cities = Lists.newArrayList(city1,city2,city3,null);        Ordering
    
      nullsFirstOrdering = Ordering.from(cityByPopulation).nullsFirst();        Collections.sort(cities,nullsFirstOrdering);        assertThat(cities.get(0),is(nullValue()));    }
    
   

9、Sort Null Last

@Test    public void testSortNullLast(){        City city1 = cityBuilder.population(100000).averageRainfall(55.0).build();        City city2 = cityBuilder.population(100000).averageRainfall(45.0).build();        City city3 = cityBuilder.population(100000).averageRainfall(33.8).build();        List
   
     cities = Lists.newArrayList(null,city1,city2,city3);        Ordering
    
      nullsLastOrdering = Ordering.from(cityByPopulation).nullsLast();        Collections.sort(cities,nullsLastOrdering);        assertThat(cities.get(3),is(nullValue()));    }
    
   

更多功能等待你的发现。

转载地址：https://carlzone.blog.csdn.net/article/details/51866095 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！