简单了解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 可简化与 java api 的交互。例如普遍的 java 代码语句 person.getinformation().

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

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

您可以为第一个参数编写一个正式函数定义，比如 (fn [x] (< 1 (count x)))，但使用 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)))

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

函数式编程的优势

在一篇标题为 “beating the averages” 的著名文章中，paul graham 定义了 blub paradox：他 “编造” 了一种名为 blub 的虚假语言，并且考虑在其他语言与 blub 之间进行功能比较：

只要我们假想的 blub 程序员往下看一连串功能，他就知道自己是在往下看。不如 blub 功能强大的语言显然不怎么强大，因为它们缺少程序员习惯使用的一些功能。但当我们假想的 blub 程序员从另一个方向，也就是说，往上看一连串功能时，他并没有意识到自己在往上看。他看到的只不过是怪异的语言。他可能认为它们在功能上与 blub 几近相同，只是多了其他难以理解的东西。blub 对他而言已经足够好，因为他是在 blub 环境中可以思考问题。

对于很多 java 开发人员而言，清单 2 中的代码看起来陌生而又奇怪，因此难以将它看作是有优势的代码。但当您停止过于细化任务执行细节时，就释放了越来越智能的语言和运行时的潜能，从而做出了强大的改进。例如，jvm 的到来（解除了开发人员的内存管理困扰）为先进垃圾回收的创建开辟了全新的研发领域。使用命令式编码时，您深陷于迭代循环的细节，难以进行并行性等优化。从更高的层面思考操作（比如 filter、map 和 reduce）可将概念与实现分离开来，将并行性等修改从一项复杂、详细的任务转变为一个简单的 api 更改。

想一想如何将 清单 1 中的代码变为多线程代码。由于您密切参与了 for 循环期间发生的细节，所以您还必须处理烦人的并发代码。然后思考一下清单 6 所示的 scala 并行版本。

清单 6. 实现进程并行性

val parallelresult = employees
.par
.filter(f => f.length() > 1)
.map(f => f.capitalize)
.reduce(_ + "," + _)

清单 2 与 清单 6 之间惟一的差别在于，将 .par 方法添加到了命令流中。.par 方法返回后续操作依据的集合的并行版本。由于我将对集合的操作指定为高阶概念，所以底层运行时可以*地完成更多的工作。

面向命令式对象的开发人员往往会考虑使用重用类，因为他们的语言鼓励将类作为构建块。函数编程语言倾向于重用函数。函数式语言构建复杂的通用功能（比如 filter()、map() 和 reduce()）并通过作为参数提供的函数来实现定制。在函数式语言中，将数据结构转换为列表和映射等标准集合是很寻常的事，因为它们接着就可以被强大的内置函数所操控。

例如，在 java 环境中存在许多 xml 处理框架，每个框架都封装自己的私有版本的 xml 结构，并通过自己的方法交付它。在 clojure 这样的语言中，xml 被转换为基于映射的标准数据结构，该结构对已经存在于语言中的强大的变换、约简和筛选操作开放。

结束语

所有现代语言都包含或添加了函数式编程结构，使函数式编程成为未来开发中不可或缺的一部分。java 下一代语言都实现了强大的函数式功能，有时使用不同的名称和行为。在本期中，我介绍了 scala、groovy 和 clojure 中的一种新编码风格并展示了一些优势。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。