java 8函数式编程与Lambda表达式

桃扇骨 2022-08-09 02:18 202阅读 0赞

这篇文章不是我原创的，见其简 单易懂，就拿过来了。原文详见http://www.infoq.com/cn/articles/Concise-Java?utm\_source=infoq&utm\_medium=related\_content\_link&utm\_campaign=relatedContent\_articles\_clk

[Java的设计目标][Java]包括面向对象、易于上手（在当时，这意味着使用C++格式的语法），健壮、安全、可移植、多线程以及高性能。简洁并非其中之一。相比于用面向对象语法实现的任务，函数式语言所提供的替代方案要简洁的多。[Java 8中新增的Lambda表达式][Java 8_Lambda]改变了Java的表现形式，减少了执行许多通用任务所需的代码数量，为Java开启了函数式编程习语的大门。

## 函数式编程 ##

函数式编程将函数作为程序开发人员的核心结构。开发人员可以以一种非常灵活的方式使用函数，例如将其作为参数传递。利用Lambda表达式的这种能力，Java可以将函数作为方法的参数，或者将代码作为数据。Lambda表达式可以看作是一个与任何特定的类都无关的匿名方法。这些理念有着非常丰富多彩并且引人入胜的数学基础。

函数式编程和Lambda表达式仍然是比较抽象、深奥的概念。对于开发人员来说，主要关注如何解决实际生产中的任务，对于跟踪最新的计算趋势可能并不感兴趣。随着Lambda表达式在Java中的引入，对于开发人员来说对这些新特性的了解至少需要能够达到可以读懂其他开发人员所编写代码的程度。这些新特性还能带来实际的好处——可以影响并发系统的设计，使其拥有更优的性能。而本文所关心的是如何利用这些机制编写简洁而又清晰的代码。

之所以能够用Lambda表达式生成简洁的代码，有如下几个原因。局部变量的使用量减少，因此声明和赋值的代码也随之减少。循环被方法调用所替代，从而将三行以上的代码缩减为一行。本来在嵌套循环和条件语句中的代码现在可以放置于一个单独的方法中。实现[连贯接口][Link 1]，可以将方法以类似于Unix管道的方式链接在一起。以函数式的风格编写代码的净效应并不只限于可读性。此类代码可以避免状态维护并且不会产生副作用。这种代码还能够产生易于并行化，提高处理效率的额外收益。

## Lambda表达式 ##

与Lambda表达式相关的语法比较简单直白，不过又有别于Java之前版本的习语。一个Lambda表达式由三部分组成，参数列表、箭头和主体。参数列表可以包含也可以不包含括号。此外还新增了由双冒号组成的相关操作符，可以进一步缩减某些特定的Lambda表达式所需的代码量。这又称为[方法引用][Link 2]。

## 线程创建 ##

在这个示例中，将会创建并运行一个线程。Lambda表达式出现在赋值操作符的右侧，指定了一个空的参数列表，以及当线程运行时写到标准输出的简单的消息输出。

Runnable r1 = () -> System.out.print("Hi!");
     
    r1.run()

处理集合

Lambda表达式的出现会被开发人员注意到的[首要位置][Link 3]之一就是与集合API相关。假设我们需要将一个字符串列表根据长度排序。

java.util.List<String> l;
 l= java.util.Arrays.asList(new String[]{"aaa", "b", "cccc", "DD"});

可以创建一个Lambda表达式实现此功能。

java.util.Collections.sort(l, (s1, s2) ->
           new Integer(s1.length()).
               compareTo(s2.length())

这个示例中包含两个传递给Lambda表达式体的参数，以比较这两个参数的长度。

除此之外还有许多替代方案，在无需使用标准的“for”或“while”循环的前提下，就可以操作列表中的各个元素。通过向集合的“forEach”方法传入Lambda表达式也可以完成用于比较的语义。这种情况下，只有一个参数传入，也就无需使用括号。

l.forEach(e -> System.out.println(e));

这个特殊的示例还可以通过使用方法引用将包含类和静态方法分开的方式进一步减少代码量。每个元素都会按顺序传入println方法。

l.forEach(System.out::println)

[java.util.stream][]是在Java 8中新引入的包，以函数式程序开发人员所熟悉的语法处理集合。在包的摘要中对包中的内容解释如下：“为流元素的函数式操作提供支持的类，如对集合的map-reduce转换。”

下方的类图提供了对该包的一个概览，着重介绍了接下来的示例中将要用到的功能。包结构中列示了大量的Builder类。这些类与[连贯接口][Link 4]一样，可以将方法链接成为管道式的操作集。

字符串解析和集合处理虽然简单，在真实世界中仍有许多实际应用场景。在进行自然语言处理（NLP）时，需要将句子分割为单独的词。生物信息学将DNA和RNA表示为有字母组成的碱基，如C，G，A，T或U。在每个问题领域中，字符串对象会被分解，然后针对其各个组成部分进行操作、过滤、计数以及排序等操作。因此，尽管示例中所包含的用例十分简单，其理念仍适用于各类有实际意义的任务。

下方的示例代码解析了一个包含一个句子的字符串对象，并统计单词的数量和感兴趣的字母。包括空白行在内，整个代码清单的行数不超过70行。

1. import java.util.*; 2. 3. import static java.util.Arrays.asList; 4. import static java.util.function.Function.identity; 5. import static java.util.stream.Collectors.*; 6. 7. public class Main { 8. 9.    public static void p(String s) { 10.        System.out.println(s.replaceAll("[\\]\\[]", "")); 11.   } 12. 13.   private static List uniq(List letters) { 14.        return new ArrayList(new HashSet(letters)); 15.   } 16. 17.    private static List sort(List letters) { 18.        return letters.stream().sorted().collect(toList()); 19.    } 20. 21.    private static  Map uniqueCount(List letters) { 22.        return letters.stream(). 23.                collect(groupingBy(identity(), counting())); 24.    } 25. 26.    private static String getWordsLongerThan(int length, List words) { 27.        return String.join(" | ", words 28.                        .stream().filter(w -> w.length() > length) 29.                        .collect(toList()) 30.        ); 31.    } 32. 33.    private static String getWordLengthsLongerThan(int length, List words) 34.    { 35.        return String.join(" | ", words 36.                .stream().filter(w -> w.length() > length) 37.                .mapToInt(String::length) 38.                .mapToObj(n -> String.format("%" + n + "s", n)) 39.                .collect(toList())); 40.    } 41. 42.    public static void main(String[] args) { 43. 44.        String s = "The quick brown fox jumped over the lazy dog."; 45.        String sentence = s.toLowerCase().replaceAll("[^a-z ]", ""); 46. 47.        List words = asList(sentence.split(" ")); 48.        List letters = asList(sentence.split("")); 49. 50.        p("Sentence : " + sentence); 51.        p("Words : " + words.size()); 52.        p("Letters : " + letters.size()); 53. 54.        p("\nLetters : " + letters); 55.        p("Sorted : " + sort(letters)); 56.        p("Unique : " + uniq(letters)); 57. 58.        Map m = uniqueCount(letters); 59.        p("\nCounts"); 60. 61.        p("letters"); 62.        p(m.keySet().toString().replace(",", "")); 63.        p(m.values().toString().replace(",", "")); 64. 65.        p("\nwords"); 66.        p(getWordsLongerThan(3, words)); 67.        p(getWordLengthsLongerThan(3, words)); 68.     } 69. }

示例程序执行输出：

Sentence : the quick brown fox jumped over the lazy dog
    Words    : 9
    Letters  : 44
    
    Letters  : t, h, e,  , q, u, i, c, k,  , b, r, o, w, n,  , f, o, x,  , j, u, m, p, e, d,  , o, v, e, r,  , t, h, e,  , l, a, z, y,  , d, o, g
    Sorted   :  ,  ,  ,  ,  ,  ,  ,  , a, b, c, d, d, e, e, e, e, f, g, h, h, i, j, k, l, m, n, o, o, o, o, p, q, r, r, t, t, u, u, v, w, x, y, z
    Unique   :  , a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, t, u, v, w, x, y, z
    
    Counts
    letters
      a b c d e f g h i j k l m n o p q r t u v w x y z 8 1 1 1 2 4 1 1 2 1 1 1 1 1 1 4 1 1 2 2 2 1 1 1 1 1
    
    words
    quick | brown | jumped | over | lazy
       5 |    5 |     6 |   4 |   4

上述代码已经经过了多重精简。其中一些方式并非在各个版本的Java中都可行，而且有些方式可能并不符合公认的编码风格指南。思考一下在较早版本的Java中如何才能够获得相同的输出？首先，需要创建许多局部变量用于临时存储数据或作为索引。其次，需要通过许多条件语句和循环告知Java如何处理数据。新的函数式编程方式更加专注于需要什么数据，而并不关心与其相关的临时变量、嵌套循环、索引管理或条件语句的处理。

在某些情况下，采用早期版本中的标准Java语法以减少代码量是以牺牲清晰度为代价的。例如，示例代码第一行的标准import语句中的Java包引用了java.util下的所有类，而不是根据类名分别引用。对System.out.println的调用被替换为对一个名为p的方法的调用，这样在每次方法调用时都可以使用短名称（行9-11）。由于可能违反某些Java的编码规范，这些改变富有争议，不过有着其他背景的程序开发人员查看这些代码时可能并不会有何问题。

另外一些情况下，则利用了从JDK8预览版才新增的功能特性。静态引用（行3-5）可以减少内联所需引用的类的数量。而正则表达式（行10，45）则可以用与函数式编程本身无关的方式，有效隐藏循环和条件语句。这些习语，特别是正则表达式的使用，经常会因为难以阅读和说明而受到质疑。如果运用得当，这些习语可以减少噪音的数量，并且能够限制开发人员需要阅读和说明的代码数量。

最后，示例代码利用了JDK 8中新增的Streaming API。使用了Streaming API中大量的方法对列表进行过滤、分组和处理（行17-40）。尽管在IDE中它们与内附类的关联关系很清晰，不过除非你已经很熟悉这些API，否则这种关系并不是那么显而易见。下表展示了示例代码中所出现的每一次方法调用的来源。

<table style="border-collapse:collapse; border-spacing:0px; margin:10px 0px; border:1px solid rgb(224,224,224); padding:0px"> 
 <tbody style="margin:0px; border:0px; padding:0px"> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> 方法 </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> 完整的方法名称引用 </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> stream() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.Collection.stream() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> sorted() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Stream.sorted() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> collect() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Stream.collect() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> toList() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Collectors.toList() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> groupingBy() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Collectors.groupingBy() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> identity() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.function.Function.identity() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> counting() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Collectors.counting() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> filter() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Stream.filter() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> mapToInt() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Stream.mapToInt() </td> 
 </tr> 
 <tr style="margin:0px; border:0px; padding:0px"> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> mapToObject() </td> 
 <td style="margin:0px; padding:0px; border:1px solid rgb(224,224,224)"> java.util.stream.Stream.mapToObject() </td> 
 </tr> 
 </tbody> 
</table>

uniq()（行13）和sort()（行17）方法体现了同名的Unix实用工具的功能。sort引入了对流的第一次调用，首先对流进行排序，然后再将排序后的结果收集到列表中。UniqueCount()（行21）与uniq -c类似，返回一个map对象，其中每个键是一个字符，每个值则是这个字符出现次数的统计。两个“getWords”方法（行26和行33）用于过滤出比给定长度短的单词。getWordLengthsLongerThan()方法调用了一些额外的方法，将结果格式化并转换成不可修改的String对象。

整段代码并未引入任何与Lambda表达式相关的新概念。之前所介绍的语法只适用于Java Stream API特定的使用场景。

## 总结 ##

用更少的代码实现同样任务的理念与爱因斯坦的理念一致：“必须尽可能地简洁明了，但又不能简单地被简单。”Lambda表达式和新的Stream API因其能够实现扩展性良好的简洁代码而备受关注。它们让程序开发人员可以恰当地将代码简化成最好的表现形式。

函数式编程习语的设计理念就是简短，而且仔细思考一下就会发现许多可以让Java代码更加精简的场景。新的语法虽然有点陌生但并非十分复杂。这些新的功能特性清晰地表明，作为一种语言，Java已经远远超越其最初的目标。它正在用开放的态度接受其他程序设计语言中最出色的一些功能，并将它们整合到Java之中。

[Java]: http://www.oracle.com/technetwork/java/intro-141325.html
[Java 8_Lambda]: http://www.drdobbs.com/jvm/lambda-expressions-in-java-8/240166764
[Link 1]: http://en.wikipedia.org/wiki/Fluent_interface
[Link 2]: http://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html
[Link 3]: http://www.drdobbs.com/jvm/lambdas-and-streams-in-java-8-libraries/240166818
[java.util.stream]: http://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html
[Link 4]: http://martinfowler.com/bliki/FluentInterface.html