Java函数式编程(五)：闭包

使用词法作用域和闭包

很多开发人员都存在这种误解，认为使用lambda表达式会导致代码冗余，降低代码质量。恰恰相反，就算代码变得再复杂，我们也不会为了代码的简洁性而在代码质量上做任何妥协，下面我们就会看到。

在前面一个例子中我们已经可以重用lambda表达式了;然而，如果再匹配另外一个字母，代码冗余的问题很快又卷土重来了。我们先来进一步分析下这个问题，然后再用词法作用域和闭包来把它解决掉。

lambda表达式带来的冗余

我们来从friends中过滤出那些以n或者b开头的字母。继续延用上面的那个例子，我们写出的代码可能会是这样的：

final predicate<string> startswithn = name -> name.startswith("n");
final predicate<string> startswithb = name -> name.startswith("b");
final long countfriendsstartn =
friends.stream()
.filter(startswithn).count();
final long countfriendsstartb =
friends.stream()
.filter(startswithb).count();

第一个predicate判断名字是否是以n开头的，而第二个是判断是否以b开头的。我们把这两个实例分别传递给两次filter方法调用。这样看起来很合理，但是两个predicate产生了冗余，它们只是那个检查的字母不同而已。我们来看下如何能避免这种冗余。

使用词法作用域来避免冗余

第一个方案，我们可以把字母抽出来作为函数的参数，同时把这个函数传递给filter方法。这是个不错的方法，不过filter可不是什么函数都接受的。它只接受只有一个参数的函数，那个参数对应的就是集合中的元素，返回一个boolean值，它希望传进来的是一个predicate。

我们希望有一个地方能把这个字母先缓存起来，一直到参数传递过来（在这里就是name这个参数）。下面来新建一个这样的函数。

public static predicate<string> checkifstartswith(final string letter) {
return name -> name.startswith(letter);
}

我们定义了一个静态函数checkifstartswith，它接收一个string参数，并且返回一个predicate对象，它正好可以传递给filter方法，以便后面进行使用。不像前面看到的高阶函数那样是以函数作为参数的，这个方法返回的是一个函数。不过它也是一个高阶函数，这个我们在12页的进化，而非变革中已经提到过了。

checkifstartswith方法返回的predicate对象和其它lambda表达式有些不同。在 return name -> name.startswith(letter)语句中，我们很清楚name是什么，它是传入到lambda表达式中的参数。不过变量letter到底是什么？它是在这个匿名函数的域外边的，java找到了定义这个lambda表达式的域，并发现了这个变量letter。这个就叫做词法作用域。词法作用域是个很有用的东西，它使得我们可以在一个用用域中缓存一个变量，以便后面在另一个上下文中进行使用。由于这个lambda表达式使用了它的定义域中的变量，这种情况也被称作闭包。关于词法作用域的访问限制，可以看下31页的词法作用域有什么限制吗？

词法作用域有什么限制吗？

在lambda表达式中，我们只能访问它的定义域中的final类型或者实际上是final类型的本地变量。
lambda表达式可能马上就会被调用，也可能延迟进行调用，或者从不同的线程发起调用。为了避免竞争冲突，我们访问的定义域中的本地变量，一旦初始化后是不允许进行修改的。任何修改操作都会导致编译异常。

标记成final后解决了这个问题，不过java并不强迫我们一定要这么标记。事实上，java看的是两点。一个是访问的这个变量必须要在定义它的方法中完成初始化，并且要在定义lambda表达式之前。第二，这些变量的值不能进行修改——也就是说，它们事实上就是final类型的，尽管没有这么标记。
无状态的lambda表达式是运行时常量，而那些使用了本地变量的lambda表达则会有额外的计算开销。

在调用filter方法的时候我们就可以用checkifstartswith方法返回的lambda表达式了，就像这样：

final long countfriendsstartn =
friends.stream() .filter(checkifstartswith("n")).count();
final long countfriendsstartb = friends.stream()
.filter(checkifstartswith("b")).count();

在调用filter方法之前 ，我们先调用了checkifstartswith()方法，把想要的字母传参进去。这个调用很快就返回了一个lambda表达式，然后我们把它传参给filter方法。

通过创建了一个高阶函数（这里是checkifstartswith）并且使用了词法作用域，我们成功的去除了代码中的冗余。我们不用再重复的判断name是不是以某个字母开头了。

重构，缩小作用域

在前面的例子中我们用了一个static方法，不过我们不希望用static方法来缓存变量，这样把我们的代码搞乱了。最好能把这个函数的作用域缩小到使用它的地方。我们可以用一个function接口来实现这个。

final function<string, predicate<string>> startswithletter = (string letter) -> {
predicate<string> checkstarts = (string name) -> name.startswith(letter);
return checkstarts; };

这个lambda表达式取代了原来的static方法，它可以放到函数里面，在需要用到它之前定义一下就好了。startwithletter变量引用的是一个入参是string，出参是predicate的function。

和使用static方法相比，这个版本简单多了，不过我们还可以对它继续重构让它更简洁点。从实际的角度看，这个函数和前面的static方法是一样的；它们都接收一个string返回一个predicate。为了不显式的声明一个predicate， 我们用一个lamdba表达式整个给替换掉。

final function<string, predicate<string>> startswithletter = (string letter) -> (string name) -> name.startswith(letter);

我们把那些乱七八糟的东西给干掉了，但是我们还可以去掉类型声明，让它更简洁一点，java编译器会根据上下文去做类型推导的。我们来看下改进后的版本。

final function<string, predicate<string>> startswithletter =
letter -> name -> name.startswith(letter);

要适应这种简洁的语法可得下点工夫。如果它亮瞎了你的眼睛的话，先看看别的地方吧。我们已经完成了代码的重构，现在可以用它来替换掉原来的checkifstartswith()方法了，就像这样：

final long countfriendsstartn = friends.stream()
.filter(startswithletter.apply("n")).count();
final long countfriendsstartb = friends.stream()
.filter(startswithletter.apply("b")).count();

在这节中我们用到了高阶函数。我们看到了如果把函数传递给另一个函数，如何在函数中创建函数，以及如何通过函数来返回一个函数。这些例子都展示了lambda表达式带来的简洁性和可重用性。

本节中我们充分发挥了function和predicate的作用，不过我们来看下它们两个到底有什么区别。predicate接受一个类型为t的参数，返回一个boolean值来代表它对应的判断条件的真假。当我们需要做条件判断的时候，我们可以使用predicateg来完成。像filter这类对元素进行筛选的方法都接收predicate作为参数。而funciton代表的是一个函数，它的入参是类型为t的变量，返回的是r类型的一个结果。它和只能返回boolean的predicate相比要更加通用。只要是将输入转化成一个输出的，我们都可以使用function，因此map使用function作为参数也是情理之中的事情了。

可以看到，从集合中选取元素非常简单。下面我们将介绍下如何从集合中只挑选出一个元素。