好程序员Java 培训分享 Java 函数式编码结构，本文将探讨三种下一代 JVM 语言： Groovy 、 Scala 和 Clojure ，比较并对比新的功能和范例，让 Java 开发人员对自己近期的未来发展有大体的认识，下面我们一起来看一下吧。

　　当垃圾回收成为主流时，它消除了所有类别的难以调试的问题，使运行时能够为开发人员管理复杂的、容易出错的进程。函数式编程旨在为你编写的算法实现同样的优化，这样你就可以从一个更高的抽象层面开展工作，同时运行时执行复杂的优化。

　　Java 下一代语言并不都占用从命令式到函数式的语言频谱的同一位置，但都展现出函数功能和习语。函数式编程技术有明确定义，但语言有时为相同的函数式概念使用不同的术语，使得我们很难看到相似之处。在本期文章中，我比较了 Scala 、 Groovy 和 Clojure 的函数式编码风格并讨论了它们的优势。

　　命令式处理

　　我要首先探讨一个常见问题及其命令式解决方案。假如给定一个名称列表，其中一些名称包含一个字符。系统会要求你在一个逗号分隔的字符串中返回名称，该字符串中不包含单字母的名称，每个名称的首字母都大写。实现该算法的Java 代码如清单 1 所示。

　　清单1. 命令式处理

　　public class TheCompanyProcess {

　　public String cleanNames(List<String> listOfNames) {

　　StringBuilder result = new StringBuilder();

　　for(int i = 0; i < listOfNames.size(); i++) {

　　if (listOfNames.get(i).length() > 1) {

　　result.append(capitalizeString(listOfNames.get(i))).append(",");

　　}

　　}

　　return result.substring(0, result.length() - 1).toString();

　　}

　　public String capitalizeString(String s) {

　　return s.substring(0, 1).toUpperCase() + s.substring(1, s.length());

　　}

　　}

　　由于你必须处理整个列表，解决清单1 中问题最简单的方式是使用一个命令式循环。对于每个名称，都需要进行检查，确认其长度是否大于 1 ，然后（如果长度大于 1 ）将首字母大写的名称附加到 result 字符串，并在后面加逗号。最终字符串中的最后一个名称不应包含逗号，所以我将它从最后返回值中移走。

　　在命令式编程中，建议你在较低级上别执行操作。在清单1 中的 cleanNames() 方法中，我执行了三个任务：我筛选列表以消除单字符，将列表中每个名称的首字母变换为大写，然后将列表转化为一个字符串。在命令式语言中，我不得不为三个任务都使用同一低级机制（对列表进行迭代）。函数式语言将筛选、变换和转化视为常见操作，因此它们提供给你从不同视角解决问题的方式。

　　函数式处理

　　函数编程语言与命令式语言的问题分类方式不同。筛选、变换和转化逻辑类别表现为函数。那些函数实现低级变换并依赖于开发人员来编写作为参数传递的函数，进而定制函数的行为。我可以用伪代码将清单1 中的问题概念化为：

　　listOfEmps -> filter(x.length > 1) -> transform(x.capitalize) ->

　　convert(x, y -> x + "," + y)

　　利用函数式语言，你可以建模这一概念性解决方案，无需担心实现细节。

　　Scala 实现

　　清单2 使用 Scala 实现清单 1 中的处理示例。它看起来就像是前面的伪代码，包含必要的实现细节。

　　清单2.Scala 处理

　　val employees = List("neal", "s", "stu", "j", "rich", "bob")

　　val result = employees

　　.filter(_.length() > 1)

　　.map(_.capitalize)

　　.reduce(_ + "," + _)

　　对于给定的名称列表，我首先筛选它，剔除长度不大于1 的所有名称。然后将该操作的输出提供给 map() 函数，该函数对集合的每个元素执行所提供的代码块，返回变换后的集合。最后，来自 map() 的输出集合流向 reduce() 函数，该函数基于代码块中提供的规则将每个元素结合起来。

　　在本例中，我将每对元素结合起来，用插入的逗号连接它们。我不必考虑三个函数调用中参数的名称是什么，所以我可以使用方便的Scala 快捷方式，也就是说，使用 _ 跳过名称。 reduce() 函数从前两个元素入手，将它们结合成一个元素，成为下一个串接中的第一个元素。在“浏览”列表的同时， reduce() 构建了所需的逗号分隔的字符串。

　　我首先展示Scala 实现是因为我对它的语法比较熟悉，而且 Scala 分别为筛选、变换和转化概念使用了行业通用的名称，即 filter 、 map 和 reduce 。

　　Groovy 实现

　　Groovy 拥有相同的功能，但对它们进行命名的方式与脚本语言（比如 Ruby ）更加一致。清单 1 中处理示例的 Groovy 版本如清单 3 所示。

　　清单3.Groovy 处理

　　class TheCompanyProcess {

　　public static String cleanUpNames(List listOfNames) {

　　listOfNames

　　.findAll {it.length() > 1}

　　.collect {it.capitalize()}

　　.join(',')

　　}

　　}

　　尽管清单3 在结构上类似于清单 2 中的 Scala 示例，但方法名称不同。 Groovy 的 findAll 集合方法应用所提供的代码块，保留代码块为 true 的元素。如同 Scala ， Groovy 包含一个隐式参数机制，为单参数代码块使用预定义的 it 隐式参数。 collect 方法（ Groovy 的 map 版本）对集合的每个元素执行所提供的代码块。 Groovy 提供一个函数 (join()) ，使用所提供的分隔符将字符串集合串联为单一字符串，这正是本示例中所需要的。

　　Clojure 实现

　　Clojure 是一个使用 reduce 、 map 和 filter 函数名的函数式语言，如清单 4 所示。

　　清单4.Clojure 处理示例

　　(defn process [list-of-emps]

　　(reduce str (interpose ","

　　(map clojure.string/capitalize

　　(filter #(< 1 (count %)) list-of-emps)))))

　　Clojure 的 thread-first 宏

　　thread-last 宏使集合的处理变得更加简单。类似的 Clojure 宏 thread-first 可简化与 JavaAPI 的交互。例如普遍的 Java 代码语句 person.getInformation().

　　getAddress().getPostalCode() ，这体现了 Java 违反迪米特法则的倾向。这种类型的语句给 Clojure 编程带来一些烦恼，迫使使用 JavaAPI 的开发人员不得不构建由内而外的语句，比如 (getPostalCode(getAddress(getInformationperson))) 。 thread-first 宏消除了这一语法困扰。你可以使用宏将嵌套调用编写为 (->persongetInformationgetAddressgetPostalCode) ，想嵌套多少层都可以。

　　如果你不习惯查看Clojure ，可以使用清单 4 中的代码，其结构可能不够清晰。 Clojure 这样的 Lisp 是“由内而外”进行工作的，所以必须从最后的参数值 list-of-emps 着手。 Clojure 的 (filter) 函数接受两个参数：用于进行筛选的函数（本例中为匿名函数）和要筛选的集合。

　　你可以为第一个参数编写一个正式函数定义，比如(fn[x](<1(countx))) ，但使用 Clojure 可以更简洁地编写匿名函数。与前面的示例一样，筛选操作的结果是一个较少的集合。 (map) 函数将变换函数接受为第一个参数，将集合（本例中是 (filter) 操作的返回值）作为第二个参数。 Clojure 的 (map) 函数的第一个参数通常是开发人员提供的函数，但接受单一参数的任何函数都有效；内置 capitalize 函数也符合要求。

　　最后，(map) 操作的结果成为了 (reduce) 的集合参数。 (reduce) 的第一个参数是组合函数（应用于 (interpose) 的返回的 (str) ）。 (interpose) 在集合的每个元素之间（除了最后一个）插入其第一个参数。

　　当函数嵌套过多时，即使最有经验的开发人员也会倍感头疼，如清单4 中的 (process) 函数所示。所幸的是， Clojure 包含的宏支持你将结构“调整”为更可读的顺序。清单 5 中的功能与清单 4 中的功能一样。

　　清单5. 使用 Clojure 的 thread-last 宏

　　(defn process2 [list-of-emps]

　　(->> list-of-emps

　　(filter #(< 1 (count %)))

　　(map clojure.string/capitalize)

　　(interpose ",")

　　(reduce str)))

　　Clojurethread-last 宏采取对集合应用各种变换的常见操作并颠倒典型的 Lisp 的顺序，恢复了从左到右的更自然的阅读方式。在清单 5 中，首先是 (list-of-emps) 集合。代码块中每个随后的表单被应用于前一个表单。 Lisp 的优势之一在于其语法灵活性：任何时候代码的可读性变得很差时，你都可以将代码调整回具有较高可读性。