引言

日常搬砖时，经常有这种情况，根据不同策略对返回前端的列表元素进行各种重排序，于是有了这篇文章，学会使用Guava Orderiing。

Guava Ordering

依然，引用下官方定义：

排序器(Ordering)是Guava流畅风格比较器[Comparator]的实现，它可以用来为构建复杂的比较器，以完成集合排序的功能。

API及基本使用

在使用方面，Ordering提供了链式调用的支持，使得代码变得清晰简洁。

为了清晰地了解Ordering的运行，以由Entity对象组成的列表进行不同排序（笔者偷懒没有使用Getter和Setter，直接public声明了成员变量。）。

public class Entity {
 public int status;
 public String name;
 public Entity(int status, String name) {
 this.status = status;
 this.name = name;
 }
 public Entity(int status) {
 this.status = status;
 }
 @Override
 public String toString() {
 return "Entity{" +
 "status=" + status +
 ", name='" + name + '\'' +
 '}';
 }
}

测试数据

List<Entity> list = new ArrayList<Entity>() {{
 add(new Entity(1, "h"));
 add(new Entity(2, "f"));
 add(new Entity(3, "a"));
 add(new Entity(0, "d"));
 add(new Entity(2, "b"));
 }};

Ordering的初始化

Ordering的初始化方法主要有三种，分别用于不同的场景。

1、对可排序的数据类型的排序器

// 整型按照大小排序
Ordering<Integer> integerOrdering = Ordering.natural();
// 日期先后排序
Ordering<Date> dateOrdering = Ordering.natural();

2、按对象的字符串形式做字典排序[lexicographical ordering]

// 排序结果：[Entity{status=0, name='d'}, Entity{status=1, name='h'}, Entity{status=2, name='b'}, Entity{status=2, name='f'}, Entity{status=3, name='a'}]
Ordering<Object> ordering3 = Ordering.usingToString();

3、根据自定义Comparator初始化

// 排序结果：[Entity{status=0, name='d'}, Entity{status=1, name='h'}, Entity{status=2, name='f'}, Entity{status=2, name='b'}, Entity{status=3, name='a'}]
// 按照status字段升序排序
Ordering<Entity> ordering1 = Ordering.from(Comparator.comparingInt(o -> o.status));

链式调用方法

reverse()

// 倒序排序
// 排序结果：[Entity{status=3, name='a'}, Entity{status=2, name='f'}, Entity{status=2, name='b'}, Entity{status=1, name='h'}, Entity{status=0, name='d'}]
Ordering<Object> ordering3 = Ordering.usingToString().reverse();

nullsFirst()、nullsLast()：将null值排到最前面/最后面位置。
compound(Comparator<? super U> secondaryComparator)：合成另一个比较器，以处理当前排序器中的相等情况。

// status升序排序
Ordering<Entity> ordering1 = Ordering.from(Comparator.comparingInt(o -> o.status));
// status相等，按照name升序排序
// 排序结果：[Entity{status=0, name='d'}, Entity{status=1, name='h'}, Entity{status=2, name='b'}, Entity{status=2, name='f'}, Entity{status=3, name='a'}]
Ordering<Entity> ordering4 = ordering1.compound((o1, o2) -> StringUtils.compare(o1.name, o2.name));

onResultOf(Function<F, ? extends T> function)

// status升序 null的对象放在最后面
// 排序结果：[Entity{status=0, name='d'}, Entity{status=1, name='h'}, Entity{status=2, name='f'}, Entity{status=2, name='b'}, Entity{status=3, name='a'}, null]
Ordering<Entity> ordering = Ordering.natural().onResultOf(new Function<Entity, Comparable>() {
 @Override
 public Comparable apply(Entity entity) {
 if (entity != null) {
 return entity.status;
 }
 return -1;
 }
 }).nullsLast();

运用排序器方法

greatestOf(Iterable iterable, int k)/leastOf

// 排序结果：[null, Entity{status=3, name='a'}, Entity{status=2, name='f'}, Entity{status=2, name='b'}]
// nullLast()导致null最大，最大的四个元素
ordering.greatestOf(list, 4)
// 排序结果：[Entity{status=0, name='d'}, Entity{status=1, name='h'}, Entity{status=2, name='f'}, Entity{status=2, name='b'}]
// 最小的四个元素
ordering.leastOf(list, 4)

min(Iterable iterable)/max

// 结果：Entity{status=0, name='d'}
ordering.min(list)
// 还支持N个对象的比较
// 结果：Entity{status=1, name='y'}
ordering.min(new Entity(1, "y"), new Entity(2, "x"))

sortedCopy(Iterable iterable)来看源码看下做了什么？

public <E extends T> List<E> sortedCopy(Iterable<E> iterable) {
// 转换成了对象数组
 E[] array = (Object[])Iterables.toArray(iterable);
 // Ordering继承Comparator，使用Ordering排序
 Arrays.sort(array, this);
 // 最后复制到新建列表中
 return Lists.newArrayList(Arrays.asList(array));
 }

源码可以看到，Ordering将排序结果作为新的列表对象，原有列表没有改动。

// 数据：
 List<Entity> list = new ArrayList<Entity>() {{
 add(new Entity(1, "h"));
 add(new Entity(2, "f"));
 add(new Entity(3, "a"));
 add(new Entity(0, "d"));
 add(new Entity(2, "b"));
 add(null);
 }};
// 结果：[Entity{status=0, name='d'}, Entity{status=1, name='h'}, Entity{status=2, name='f'}, Entity{status=2, name='b'}, Entity{status=3, name='a'}, null]
[Entity{status=1, name='h'}, Entity{status=2, name='f'}, Entity{status=3, name='a'}, Entity{status=0, name='d'}, Entity{status=2, name='b'}, null]
System.out.println(ordering.sortedCopy(list));
 System.out.println(list);

实践：与策略模式的结合

策略模式简介

策略模式对象行为型模式，主要是定义一系列的算法，把这些算法一个个封装成单独的类。
引用下策略模式类图：

上代码

接口

public interface IEntityStrategy {
 List<Entity> sort(List<Entity> list);
}

策略1：Entity对象按照status倒序排序

public class StatusDESCStrategy implements IEntityStrategy {
 private static Ordering<Entity> ordering = Ordering.natural().onResultOf(new Function<Entity, Comparable>() {
 @Override
 public Comparable apply(Entity entity) {
 if (entity != null) {
 return entity.status;
 }
 return -1;
 }
 }).nullsLast();
 @Override
 public List<Entity> sort(List<Entity> list) {
 return ordering.sortedCopy(list);
 }
}

策略2：Entity对象按照name升序排序

public class NameASCStrategy implements IEntityStrategy {
 private static Ordering<Entity> ordering = Ordering.from((o1, o2) -> StringUtils.compare(o1.name, o2.name));
 @Override
 public List<Entity> sort(List<Entity> list) {
 return ordering.sortedCopy(list);
 }
}

测试

public class Test {
 public static void main(String[] args) {
 List<Entity> list = new ArrayList<Entity>() {{
 add(new Entity(1, "h"));
 add(new Entity(2, "f"));
 add(new Entity(3, "a"));
 add(new Entity(0, "d"));
 add(new Entity(2, "b"));
 add(null);
 }};
 Context context = new Context(new StatusDESCStrategy());
 System.out.println("status字段降序排序");
 // 结果：[Entity{status=3, name='a'}, Entity{status=2, name='f'}, Entity{status=2, name='b'}, Entity{status=1, name='h'}, Entity{status=0, name='d'}, null]
 System.out.println(context.sortByStrategy(list));
 // 结果：[Entity{status=3, name='a'}, Entity{status=2, name='b'}, Entity{status=0, name='d'}, Entity{status=2, name='f'}, Entity{status=1, name='h'}, null]
 Context context1 = new Context(new NameASCStrategy());
 System.out.println("name字段升序排序");
 System.out.println(context1.sortByStrategy(list));
 }
}

个人观点：实际为了减少对象创建，策略实践类可以使用单例模式创建，并省略Context，直接上策略类处理。

谢谢你的阅读，如果您觉得这篇博文对你有帮助，请点赞或者转发，让更多的人看到！祝你每天开心愉快！

四时宝库

程序员的知识宝库

学会使用Guava Ordering，附带实践:与策略模式的结合

引言