Guava（六）ComparisonChain和primitives包

转载出处：http://ajoo.iteye.com/blog/740079

有时候我们不可避免地要实现Comparator, 好做排序之类的事情. 

要比较两个整数的时候, 我一度曾经这么写: 

Java代码  

1. return a - b;  

多简单啊! 如果a比b大, 无疑这个东西返回正数了. 

可惜啊, 现实永远比理想残酷. java的整数不是数学中的整数, 它可能溢出地! 
Java代码  

1. int a = -2000000000;  
2. int b =  2000000000;  
3. System.out.println(a - b);  
4. // prints "294967296"  

正确的写法是: 
Java代码  

1. if (a > b) {  
2.   return 1;  
3. } else if (a < b) {  
4.   return -1;  
5. } else {  
6.   return 0;  
7. }  

但是, 太麻烦了哇! 好吧, 好吧, 我知道java是一门罗唆的语言艺术, 讲究如何如何啥的, 可是, 可是, 太麻烦了哇! 太麻烦了哇! 

在guava里, 对所有原始类型都提供了比较的工具函数来避免这个麻烦. 比如对long, 可以用Longs.compare(): 
Java代码  

1. return Longs.compare(a, b);  

其它, 自然还有Ints, Shorts, Floats, Doubles等等, 就不骗字数了. 

下面看一个简单的model类: 
Java代码  

1. class Person {  
2.   final String firstName;  
3.   final String lastName;  
4.   final int age;  
5. }  

下面我来实现一个Comparator, 按照名字然后年龄排序: 
Java代码  

1. class PersonComparator implements Comparator<Person> {  
2.   @Override public int compare(Person p1, Person p2) {  
3.     int result = p1.firstName.compareTo(p2.firstName);  
4.     if (result != 0) {  
5.       return result;  
6.     }  
7.     result = p1.lastName.compareTo(p2.lastName);  
8.     if (result != 0) {  
9.       return result;  
10.     }  
11.     return Ints.compare(p1.age, p2.age);  
12.   }  
13. }  

算中规中矩吧? 嗯, 就是觉得有点罗唆 (好啦, 好啦, "java是一门罗唆的语言艺术", 你好罗唆啊!). 要是能直接就说: 按firstName, lastName, age比较就好了. 

有一种做法是把这些东西存到一个List<Comparable>然后用一个Comparator<List>来比较: 
Java代码  

1. Ordering.natural().lexicographical().compare(  
2.     Arrays.asList(p1.firstName, p1.lastName, p1.age),  
3.     Arrays.asList(p2.firstName, p2.lastName, p2.age));  

但是这个东西有点步骤过多, 而且, 自动box那个int, 以及创建两个临时List对象, 都似乎有点过了, 毕竟, Comparator往往是被调用多次来排序很多对象的. 

对此, guava有一个相当聪明的解决办法, 用 ComparisonChain : 
Java代码  

1. class PersonComparator implements Comparator<Person> {  
2.   @Override public int compare(Person p1, Person p2) {  
3.     return ComparisonChain.start()  
4.         .compare(p1.firstName, p2.firstName)  
5.         .compare(p1.lastName, p2.lastName)  
6.         .compare(p1.age, p2.age)  
7.         .result();  
8.   }  
9. }  

这个东西的原理哪, 就是利用多态, 当p1.firstName比p2.firstName大的时候, 后续的compare()函数都是空的, 直接返回, 尽量节省计算. 
另外, 因为它对所有原始类型都做了重载, 所以也不会付装箱的代价. 

(个人意见, 不代表组织认可: 这个start()函数有点别扭. ComparisonChain应该提供静态compare()方法, 这样客户端就可以省去那个讨厌的start()) 


对了, 刚才在例子中我实在忍不住引用了 Ordering 类. 要说这个类不是做了多少了不得的事情, 它的好处是相关的功能都在一个类里面, 好找 (点一下ctrl-space, IDE的自动提示就够用了). 比较常用的几个函数:

• natural(): 比较两个Comparable.
• reverse(): 把当前ordering反过来, 大的变小, 小的变大.
• compound(): 如果当前ordering比较结果是平局, 用另外一个Comparator做加时赛.
• nullsFirst(): 把null当作最小的, 排在前面.
• nullsLast(): null最大.
• binarySearch(): 根据当前ordering在排序列表里二分查找.

比如, 上面如果我lastName可能为null, 然后我要把null列到后面, 我就可以写: 

Java代码  

1. class PersonOrdering extends Ordering<Person> {  
2.   @Override public int compare(Person p1, Person p2) {  
3.     return ComparisonChain.start()  
4.         .compare(p1.firstName, p2.firstName)  
5.         .compare(p1.lastName, p2.lastName, Ordering.<Person>natural().nullsLast())  
6.         .compare(p1.age, p2.age)  
7.         .result();  
8.   }  
9. }  

这里, 既然我已经用Ordering了, 我就顺手牵羊把PersonComparator变成PersonOrdering了.