Java中对集合排序的实现演变：从Comparable、Comparator到lambda，从啰嗦到简洁
今年初学Java，是个新人。若文中有错误纰漏，希望能指出，见谅。
目标：对 User 对象集合进行排序，要求使用简单并且代码可读性强。
User 类定义如下：
public class User { /** * id */ private String id; /** * 姓名 */ private String Name; /** * 年龄 */ private int age; /** * 身高 */ private Integer height; /** * 体重 */ private Double weight; /** * 性别 */ private boolean sex; /** * 出生年月 */ private Date birthday; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return Name; } public void setName(String name) { Name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Integer getHeight() { return height; } public void setHeight(Integer height) { this.height = height; } public Double getWeight() { return weight; } public void setWeight(Double weight) { this.weight = weight; } public boolean isSex() { return sex; } public void setSex(boolean sex) { this.sex = sex; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } }
User 对象集合定义如下：
private List<User> getUsers() throws Exception{ SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); User u1 = new User(); u1.setId(UUID.randomUUID().toString()); u1.setName("隔壁老王"); u1.setSex(false); u1.setAge(33); u1.setHeight(168); u1.setWeight(72.5); u1.setBirthday(format.parse("1970-05-13")); User u2 = new User(); u2.setId(UUID.randomUUID().toString()); u2.setName("小头爸爸"); u2.setSex(false); u2.setAge(30); u2.setHeight(172); u2.setWeight(59.8); u2.setBirthday(format.parse("1980-10-08")); User u3 = new User(); u3.setId(UUID.randomUUID().toString()); u3.setName("大头儿子的妈妈"); u3.setSex(true); u3.setAge(27); u3.setHeight(165); u3.setWeight(47.3); u3.setBirthday(format.parse("1983-11-15")); User u4 = new User(); u4.setId(UUID.randomUUID().toString()); u4.setName("大头儿子"); u4.setSex(false); u4.setAge(9); u4.setHeight(108); u4.setWeight(37D); u4.setBirthday(format.parse("2001-04-01")); List<User> data = new ArrayList<>(); data.add(u1); data.add(u2); data.add(u3); data.add(u4); return data; }
User定义中，age（年龄）的数据类型为 int，height（身高）的数据类型为 Integer，以基本类型、包类型为比较，分别对它们实现排序。
先实现对 height（身高）的排序。
实现按 height（身高）排序的方式有多种，按照“jdk版本从低到高”、“写法从复杂到简单”的次序逐一演示。
方法1:定义比较器类
List<User> data = this.getUsers(); System.out.println("原始数据:"); this.prints(data); class HeightComparator implements Comparator { public int compare(Object object1, Object object2) { User p1 = (User) object1; User p2 = (User) object2; return p1.getHeight().compareTo(p2.getHeight()); } } Collections.sort(data, new HeightComparator()); System.out.println("按身高排序后:"); this.prints(data);
方法2:定义比较器对象
List<User> data = this.getUsers(); System.out.println("原始数据:"); this.prints(data); Comparator<User> c1 = new Comparator<User>() { @Override public int compare(User o1, User o2) { return o1.getHeight() - o2.getHeight(); } }; Collections.sort(data, c1); System.out.println("按身高排序后:"); this.prints(data);
方法3:以lambda方式定义比较器对象
List<User> data = this.getUsers(); System.out.println("原始数据:"); this.prints(data); Function<User, Integer> f1 = u -> u.getHeight(); Comparator<User> c1 = Comparator.comparing(f1); //上述2句代码,也可以简化成一句: //Comparator<User> c1 = Comparator.comparing(u -> u.getHeight()); Collections.sort(data, c1); System.out.println("按身高排序后:"); this.prints(data);
jrk1.8之后实现了lambda表达式，于是有了Comsumer、Function、Predicate这些基于lambda的实现（在java里不知道概念叫什么），相应的Comparator也实现了对Function的支持，因此方法3需要jdk1.8的支持。从上述3种方式来看，代码量越来越少，也越来越优雅。
方法3已经能够一句代码实现按 height（身高）排序的功能：
Collections.sort(data, Comparator.comparing(u -> u.getHeight()));
但这仍旧不足，因为排序操作应该只需要关心“要排序的集合”和“按什么排序”，上面这句代码还多了“比较器”。不能忍，必须消灭它。
实现对List的工具类方法sort和sortDescending，分别表示顺序排序和倒序排序，实现如下：
/** * 根据指定属性对集合顺序排序 * @param data 集合对象 * @param func 委托 * @param <T> 数据类型 * @param <R> 要排序的属性的数据类型 */ public static <T, R extends Comparable<? super R>> void sort(List<T> data, Function<T, R> func){ Comparator<T> comparator = Comparator.comparing(func); data.sort(comparator); } /** * 根据指定属性对集合倒序排序 * @param data 集合对象 * @param func 委托 * @param <T> 数据类型 * @param <R> 要排序的属性的数据类型 */ public static <T, R extends Comparable<? super R>> void sortDescending(List<T> data, Function<T, R> func){ Comparator<T> comparator = Comparator.comparing(func).reversed(); data.sort(comparator); }
由于jdk中只支持对List的排序（List对象内置sort方法，Collections.sort方法虽然封装在Collections中，但其实也只支持List），因此可以将上述工具方法封装在ListUtil中，有了这2个方法，就可以像下面那样“快速”地写出可读性很高的排序了：
List<User> data = this.getUsers(); System.out.println("原始数据:"); this.prints(data); ListUtil.sort(data, a -> a.getHeight()); System.out.println("按身高顺序排序后:"); this.prints(data); ListUtil.sortDescending(data, a -> a.getHeight()); System.out.println("按身高倒序排序后:"); this.prints(data);
若想根据其他属性排序，动几下（真的是几下）手指头，就可以实现：
ListUtil.sort(data, a -> a.getAge());
ListUtil.sortDescending(data, a -> a.getWeight());
那么实现对 age（年龄）的排序，和上面是不是一样？
并不完全一样，存在较大的差异。
像上面的方法1是无法实现对 age（年龄）的排序的，因为该属性数据类型为 int。
我们来看一下方法1中一句关键代码：
return p1.getHeight().compareTo(p2.getHeight());
Heigth是Integer类型，而这种包装类，都是继承了Comparable接口并实现了compareTo方法的，因此上述代码中可以直接使用compareTo方法。但基本类型int并没有该方法的实现，因此无法以方法1的方式实现排序。
方法2可以实现对 age（年龄）的排序，但当排序属性非Number类型时，这个compare写起来就微微麻烦了，因为compare的返回值的含义是“1表示大于，0表示等于，－1表示小于”。当排序属性是boolean、string等类型时，得这样写：
public int compare(User o1, User o2) { //性别属性，boolean类型 int i1 = o1.isSex() ? 1 : 0; int i2 = o2.isSex() ? 1 : 0; return i1 - i2; } public int compare(UT o1, UT o2) { //姓名属性,String类型 int i1 = (o1.getName() == null ? 0 : (o1.getName().charAt(0))); int i2 = (o2.getName() == null ? 0 : (o2.getName().charAt(0))); return i1 - i2; }
方法3可以实现对 age（年龄）的排序，并且也支持其他各种数据类型的属性，Comparaor中会有对各种数据类型（包含非Number类型）的默认排序规则，比如boolean类型按照false->true排序。
List<User> data = this.getUsers(); System.out.println("原始数据:"); this.prints(data); Function<User, Integer> f1 = u -> u.getAge(); Comparator<User> c1 = Comparator.comparing(f1); //上述2句代码,也可以简化成一句: //Comparator<User> c1 = Comparator.comparing(u -> u.getHeight()); Collections.sort(data, c1); System.out.println("按年龄排序后:"); this.prints(data);
需要说明的是，虽然 age（年龄）的数据类型是int，但Function中的返回类型不能写成int，因为Function的泛型定义并不支持基本类型。
所以，如果要对 sex（性别，数据类型是 boolean）排序，这句Function的定义得这样写：
Function<UT, Boolean> f1 = u -> u.isSex();
综上所述，无论是对 height（身高）的排序还是对 age（年龄）的排序，方法3都支持得非常棒。而前面贴出的扩展工具方法—— sort 和 sortDescending，都是基于方法3的，所以该扩展方法，适用于各种排序。
结尾。
拥抱变化吧，虽然目前java实现的lambda由于受擦除式泛型的限制，还不是非常灵活，但目前这些新写法，无论是代码数量、简洁程度、优雅性、可读性，在我看来都优于常规的for写法。虽然jdk1.8本身暴露的lambda接口寥寥无几，但我们能够去扩展去完善这些api，让集合操作更优雅简洁。
