Java函数式编程(九)：Comparator

实现comparator接口

comparator接口的身影在jdk库中随处可见，从查找到排序，再到反转操作，等等。java 8里它变成了一个函数式接口，这样的好处就是我们可以使用流式语法来实现比较器了。

我们用几种不同的方式来实现一下comparator，看看新式语法的价值所在。你的手指头会感谢你的，不用实现匿名内部类少敲了多少键盘啊。

使用comparator进行排序

下面这个例子将使用不同的比较方法，来将一组人进行排序。我们先来创建一个person的javabean。

public class person {
private final string name;
private final int age;
public person(final string thename, final int theage) {
name = thename;
age = theage;
}
public string getname() { return name; }
public int getage() { return age; }
public int agedifference(final person other) {
return age - other.age;
}
public string tostring() {
return string.format("%s - %d", name, age);
}
}

我们可以通过person类来实现comparator接口，不过这样我们只能使用一种比较方式。我们希望能比较不同的属性——比如名字，年龄，或者这些的组合。为了可以灵活的进行比较，我们可以使用comparator，当我们需要进行比较的时候，再去生成相关的代码。

我们先来创建一个person的列表，每个人都有不同的名字和年龄。

final list<person> people = arrays.aslist(
new person("john", 20),
new person("sara", 21),
new person("jane", 21),
new person("greg", 35));

我们可以通过人的名字或者年龄来对他们进行升序或者降序的排序。一般的方法就是使用匿名内部类来实现comparator接口。这样写的话只有比较相关的代码是有意义的，其它的都只是走走形式而已。而使用lambda表达式则可以聚焦到比较的本质上来。

我们先按年龄从小到大对他们进行排序。

既然我们已经有了一个list对象，我们可以用它的sort()方法来进行排序。不过这个方法也有它的问题。这是一个void方法，也就是说当我们调用这个方法的时候，这个列表会发生改动。要保留原始列表的话，我们得先拷贝出一份来，然后再调用sort()方法。这简直太费劲了。这个时候我们得求助下stream类了。

我们可以从list那获取一个stream对象，然后调用它的sorted()方法。它会返回一个排好序的集合，而不是在原来的集合上做修改。使用这个方法的话可以很方便的配置comparator的参数。

list<person> ascendingage =
people.stream()
.sorted((person1, person2) -> person1.agedifference(person2))
.collect(tolist());
printpeople("sorted in ascending order by age: ", ascendingage);

我们先通过stream()方法将列表转化成一个stream对象。然后调用它的sorted()方法。这个方法接受一个comparator参数。由于comparator是一个函数式接口，我们可以传入一个lambda表达式。最后我们调用collect方法，让它把结果存储到一个列表里。collect方法是一个归约器，它能把迭代过程中的对象输出成某种特定的格式或者类型。tolist()方法是collectors类的一个静态方法。

comparator的抽象方法compareto()接收两个参数，也就是要比较的对象，并返回一个int类型的结果。为了兼容这个，我们的lambda表达式也接收两个参数，两个person对象，它们的类型是由编译器自动推导的。我们返回一个int类型，表明比较的对象是否相等。

因为要按年龄进行排序，所以我们会比较两个对象的年龄，然后返回比较的结果。如果他们一样大，则返回0。否则如果第一个人更年轻的话就返回一个负数，更年长的话就返回正数。

sorted()方法会遍历目标集合的每个元素并调用指定的comparator，来确定出元素的排序顺序。sorted()方法的执行方式有点类似前面说到的reduce()方法。reduce()方法把列表逐步归约出一个结果。而sorted()方法则通过比较的结果来进行排序。

一旦我们排好序后我们想要把结果打印出来，因此我们调用了一个printpeople()方法;下面来实现下这个方法。

public static void printpeople(
final string message, final list<person> people) {
system.out.println(message);
people.foreach(system.out::println);
}

这个方法中，我们先打印了一个消息，然后遍历列表，打印出里面的每个元素。

我们来调用下sorted()方法看看，它会将列表中的人按年龄从小到大进行排列。

sorted in ascending order by age:
john - 20
sara - 21
jane - 21
greg - 35

我们再看一下sorted()方法，来做一个改进。

.sorted((person1, person2) -> person1.agedifference(person2))

在传入的这个lambda表达式里，我们只是简单的路由了下这两个参数——第一个参数作为agedifference()方法的调用目标，而第二个作为它的参数。但是我们可以不这么写，而是用一个office-space模式——也就是使用方法引用，让java编译器去做路由。

这里用到的参数路由和前面看到的有点不同。我们之前看到的，要么参数是作为调用目标，要么是作为调用参数。而现在，我们有两个参数，我们希望能分成两个部分，一个是作为方法调用的目标，第二个则作为参数。别担心，java编译器会告诉你，“这个我来搞定”。

我们可以把前面的sorted()方法里面的lambda表达式替换成一个短小精悍的agedifference方法。

people.stream()
.sorted(person::agedifference)

这段代码非常简洁，这多亏了java编译器提供的方法引用。编译器接收到两个person实例的参数，把第一个用作agedifference()方法的调用目标，而第二个作为方法参数。我们让编译器去做这个工作，而不是自己直接去写代码。当使用这种方式的时候，我们必须确定第一个参数就是引用的方法的调用目标，而剩下那个就是方法的入参。

重用comparator

我们很容易就将列表中的人按年龄从小到大排好序了，当然从大到小进行排序也很容易。我们来试一下。

printpeople("sorted in descending order by age: ",
people.stream()
.sorted((person1, person2) -> person2.agedifference(person1))
.collect(tolist()));

我们调用了sorted()方法并传入一个lambda表达式，它正好能适配成comparator接口，就像前面的例子那样。唯一不同的就是这个lambda表达式的实现——我们把要比较的人调了下顺序。结果应该是按他们的年龄由从大到小排列的。我们来看一下。

sorted in descending order by age:
greg - 35
sara - 21
jane - 21
john - 20

只是改一下比较的逻辑费不了太多劲。但我们没法把这个版本重构成方法引用的，因为参数的顺序不符合方法引用的参数路由的规则；第一个参数并不是用作方法的调用目标，而是作为方法参数。有一个方法能解决这个问题，同时它还能减少重复的工作。我们来看下如何实现。

前面我们已经创建了两个lambda表达式：一个是按年龄从小到大排序，一个是从大到小排序。这么做的话，会出现代码冗余和重复，并破坏了dry原则。如果我们只是想要调整下排序顺序的话，jdk提供了一个reverse方法，它有一个特殊的方法修饰符，default。我们会在77页中的default方法来讨论它，这里我们先用下这个reversed()方法来去除冗余性。

comparator<person> compareascending =
(person1, person2) -> person1.agedifference(person2);
comparator<person> comparedescending = compareascending.reversed();

我们先创建了一个comparator，compareascending，来将人按年龄从小到大进行排序。为了反转比较顺序，而不是再写一次这个代码，我们只需要调用一下这个第一个comparator的reversed()方法就可以获取第二个comparator对象。在reversed()方法底层，它创建了一个比较器，来交换了比较的参数的顺序。这说明reversed也是一个高阶方法——它创建并返回了一个无副作用的函数。我们把这个两个比较器用到代码里。

printpeople("sorted in ascending order by age: ",
      people.stream()
    
    
.sorted(compareascending)
    
    
.collect(tolist())
);
printpeople("sorted in descending order by age: ",
people.stream()
.sorted(comparedescending)
.collect(tolist())
);

从代码中明显可以看到，java8的这些新特性极大的减少了代码的冗余及复杂度，不过好处远不止这些，jdk里还有无限可能等着你去探索。

我们已经可以按年龄进行排序了，想按名字来排序的话也很简单。我们来按名字进行字典序排列，同样的，只需要改下lambda表达式里的逻辑就好了。

printpeople("sorted in ascending order by name: ",
people.stream()
.sorted((person1, person2) ->
person1.getname().compareto(person2.getname()))
.collect(tolist()));

输出的结果里会按名字的字典序进行排列。

sorted in ascending order by name:
greg - 35
jane - 21
john - 20
sara - 21

现在为止，我们要么就按年龄排序，要么就按名字排序。我们可以让lambda表达式的逻辑更智能一些。比如我们可以同时按年龄和名字排序。

我们来选出列表中最年轻的人来。我们可以先按年龄从小到大排序然后选中结果中的第一个。不过其实用不着那样，stream有一个min()方法可以实现这个。这个方法同样也接受一个comparator，不过返回的是集合中最小的对象。我们来用下它。

people.stream()
.min(person::agedifference)
.ifpresent(youngest -> system.out.println("youngest: " + youngest));

调用min()方法的时候我们用了agedifference这个方法引用。min()方法返回的是一个optinal对象，因为列表可能为空并且里面可能不止一个年纪最小的人。接着我们通过optinal的ifprsend()方法获取到年纪最小的那个人，并打印出他的详细信息。来看下输出结果。

youngest: john - 20

输出年纪最大的同样也很简单。只要把这个方法引用传给一个max()方法就好了。

people.stream()
.max(person::agedifference)
.ifpresent(eldest -> system.out.println("eldest: " + eldest));

我们来看下最年长那位的名字和年龄。

eldest: greg - 35

有了lambda表达式和方法引用之后，比较器的实现变得更简洁也更方便了。jdk也给compararor类引入了不少便利的方法，使得我们可以更流畅的进行比较，下面我们将会看到。

多重比较和流式比较

我们来看下comparator接口提供了哪些方便的新方法，并用它们来进行多个属性的比较。

我们还是继续使用上节中的那个例子。按名字排序的话，我们上面是这么写的：

people.stream()
.sorted((person1, person2) ->
person1.getname().compareto(person2.getname()));

和上个世纪的内部类的写法比起来，这种写法简直太简洁了。不过如果用了comparator类里面的一些函数能让它变得更简单，使用这些函数能够让我们更流畅的表述自己的目的。比如说，要按名字排序的话，我们可以这么写：

final function<person, string> byname = person -> person.getname();
people.stream()
.sorted(comparing(byname));

这段代码中我们导入了comparator类的静态方法comparing()。comparing()方法使用传入的lambda表达式来生成一个comparator对象。也就是说，它也是一个高阶函数，接受一个函数入参并返回另一个函数。除了能让语法变得更简洁外，这样的代码读起来也能更好的表述我们想要解决的实际问题。

有了它，进行多重比较的时候也能变得更加流畅。比如，下面这段按名字和年龄比较的代码就能说明一切：

final function<person, integer> byage = person -> person.getage();
final function<person, string> bytheirname = person -> person.getname();
printpeople("sorted in ascending order by age and name: ",
people.stream()
.sorted(comparing(byage).thencomparing(bytheirname))
.collect(tolist()));

我们先是创建了两个lambda表达式，一个返回指定人的年龄，一个返回的是他的名字。在调用sorted()方法的时候我们把这两个表达式组合 到了一起，这样就能进行多个属性的比较了。comparing()方法创建并返回了一个按年龄比较的comparator ,我们再调用这个返回的comparator上面的thencomparing()方法来创建一个组合的比较器，它会对年龄和名字两项进行比较。下面的输出是先按年龄再按名字进行排序后的结果。

sorted in ascending order by age and name:
john - 20
jane - 21
sara - 21
greg - 35

可以看到，使用lambda表达式和jdk提供的新的工具类，可以很容易的将comparator的实现进行组合。下面我们来介绍下collectors。