Guava Ordering 排序类

前言：

Guava工程是Google开发的Java核心依赖库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O ，消息总线[eventbus]等等。本文介绍，Ordering排序类，讲解一些常用的方法，以及多类型排序等。

常见的静态方法：

natural()：使用Comparable类型的自然顺序， 例如：整数从小到大，字符串是按字典顺序;

usingToString() ：使用toString()返回的字符串按字典顺序进行排序；

arbitrary() ：返回一个所有对象的任意顺序， 即compare(a, b) == 0 就是 a == b (identity equality)。

reverse()：返回一个反向的顺序

实例：

public class User implements Serializable,Comparator<User> {
    private static final Logger LOGGER_FACTORY = LoggerFactory.getLogger(User.class);

    private int id;

    private String name;

    private int age;

    public User() {
    }

    public User(Integer id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compare(User o1, User o2) {
        return Ints.compare(o1.getAge(),o2.getAge());
    }

    public static void main(String[] args) {
        User user = new User();
        User u1 = new User(1,"Tom",25);
        User u2 = new User(2,"Wind",30);
        User u3 = new User(3,"William",28);
        List<User> users = Lists.newArrayList(u1,u2,u3);

        Ordering ordering = Ordering.from(user);
        System.out.println("排序前：" + JSON.toJSONString(users));

        System.out.println("======排序后======");
        Collections.sort(users,ordering);
        System.out.println("sort result：" + JSON.toJSONString(users));
        // 从大至小，第二个参数是取几个
        List<User> max = Ordering.from(user).greatestOf(users, 1);
        User maxUser = max.get(0);
        System.out.println("maxUser = " + JSON.toJSONString(maxUser));

        // 从小直大
        List<User> min = Ordering.from(user).leastOf(users, 1);
        User minUser = min.get(0);
        System.out.println("minUser = " + JSON.toJSONString(minUser));

        //多参数排序
        InnerClass innerClass = new InnerClass();
        Ordering<User> secondaryOrdering = Ordering.from(innerClass).compound(user);
        Collections.sort(users, secondaryOrdering);
        Iterator<User> cityIterator = users.iterator();
        while (cityIterator.hasNext()) {
            System.out.println("多参数：" + JSON.toJSONString(cityIterator.next()));
        }

        //反转，以最大的值开始输出结果
        Ordering<User> reverse = Ordering.from(user).reverse();
        Collections.sort(users, reverse);
        Iterator<User> cityByRainfallIterator = users.iterator();
        while (cityByRainfallIterator.hasNext()) {
            System.out.println("反转：" + JSON.toJSONString(cityByRainfallIterator.next()));
        }
        //取1个最大值
        Ordering<User> orderingMax = Ordering.from(user);
        List<User> userMax = orderingMax.greatestOf(users, 1);
        System.out.println("最大年龄" + JSON.toJSONString(userMax.get(0)));

        //取1个最小值
        Ordering<User> orderingMin = Ordering.from(user);
        List<User> userMin = orderingMin.leastOf(users, 1);
        System.out.println("最小年龄" + JSON.toJSONString(userMin.get(0)));

        //null排序在第一个
        users.add(null);
        Ordering<User> nullsFirst = Ordering.from(user).nullsFirst();
        Collections.sort(users,nullsFirst);
        System.out.println("null排序在第一个" + JSON.toJSONString(users));
        //null排序在最后一个
        Ordering<User> nullsLast = Ordering.from(user).nullsLast();
        Collections.sort(users,nullsLast);
        System.out.println("null排序在最后" + JSON.toJSONString(users));
    }

}

class InnerClass implements Comparator<User>{
    @Override
    public int compare(User o1, User o2) {
        return Ints.compare(o1.getId(),o2.getId());
    }
}

Result:

排序前：[{"age":25,"id":1,"name":"Tom"},{"age":30,"id":2,"name":"Wind"},{"age":28,"id":3,"name":"William"}]
======排序后======
sort result：[{"age":25,"id":1,"name":"Tom"},{"age":28,"id":3,"name":"William"},{"age":30,"id":2,"name":"Wind"}]
maxUser = {"age":30,"id":2,"name":"Wind"}
minUser = {"age":25,"id":1,"name":"Tom"}
多参数：{"age":25,"id":1,"name":"Tom"}
多参数：{"age":30,"id":2,"name":"Wind"}
多参数：{"age":28,"id":3,"name":"William"}
反转：{"age":30,"id":2,"name":"Wind"}
反转：{"age":28,"id":3,"name":"William"}
反转：{"age":25,"id":1,"name":"Tom"}
最大年龄{"age":30,"id":2,"name":"Wind"}
最小年龄{"age":25,"id":1,"name":"Tom"}
null排序在第一个[null,{"age":25,"id":1,"name":"Tom"},{"age":28,"id":3,"name":"William"},{"age":30,"id":2,"name":"Wind"}]
null排序在最后[{"age":25,"id":1,"name":"Tom"},{"age":28,"id":3,"name":"William"},{"age":30,"id":2,"name":"Wind"},null]