Java 下一代: 函数式编码风格

Groovy、Scala 和 Clojure 共享的函数结构及其优势

所有 Java 下一代语言都包括函数式编程结构,让您可以从一个更高的抽象层面来思考问题。然而,语言间术语的不同使得难以看到类似的结构。本期文章将展示常见的函数式编程结构在 Java 下一代语言中的表示方式,指出那些功能在实现细节上的一些细微差别。

Neal Ford, 软件架构师, ThoughtWorks Inc.

Neal Ford 是一家全球性 IT 咨询公司 ThoughtWorks 的软件架构师和 Meme Wrangler。他的工作还包括设计和开发应用程序、教材、杂志文章、课件和视频/DVD 演示,而且他是各种技术书籍的作者或编辑,包括最近的新书 The Productive Programmer。他主要的工作重心是设计和构建大型企业应用程序。他还是全球开发人员会议上的国际知名演说家。请访问他的 Web 站点



2014 年 3 月 27 日

关于本系列

Java™ 传承的是平台,而不是语言。有超过 200 种语言可以在 JVM 上运行,它们之中不可避免地会有一种语言最终取代 Java 语言,成为编写 JVM 程序的最佳方式。本系列将探讨三种下一代 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 是一个使用 reducemapfilter 函数名的函数式语言,如清单 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 中的一种新编码风格并展示了一些优势。

在下一期中,我将深入介绍这些语言在 filter、map 和 reduce 实现方面的不同之处。

参考资料

学习

  • Scala:Scala 是一种现代函数编程语言,适用于 JVM。
  • Groovy:Groovy 是 Java 语言的一个动态变体,采用了更新的语法和功能。
  • Clojure:Clojure 是一种现代化的函数式 Lisp,运行于 JVM 之上。
  • 迪米特法则:了解一种不赞成为属性访问采用长列表的软件开发设计准则。
  • Beating the Averages(Paul Graham,2003 年 4 月):阅读了解 Graham 构建 ViaWeb(第一个在线自建电子商务网站)的经验。
  • 函数式思维:在 developerWorks 上 Neal Ford 的专栏系列中探索函数式编程。
  • 语言设计者的笔记本:在这个 developerWorks 系列中,Java 语言架构师 Brian Goetz 探讨了一些语言设计问题,这些问题为 Java 语言在 Java SE 7、Java SE 8 和更高版本中的演化带来了挑战。
  • developerWorks Java 技术专区::查找数百篇关于 Java 编程各个方面的文章。

获得产品和技术

  • 下载 IBM 产品评估版 并开始使用来自 DB2®、Lotus®、Rational®、Tivoli® 和 WebSphere® 的应用程序开发工具和中间件产品。

讨论

  • 加入 developerWorks 中文社区。探索由开发人员推动的博客、论坛、组和维基,并与其他 developerWorks 用户进行交流。

条评论

developerWorks: 登录

标有星(*)号的字段是必填字段。


需要一个 IBM ID?
忘记 IBM ID?


忘记密码?
更改您的密码

单击提交则表示您同意developerWorks 的条款和条件。 查看条款和条件

 


在您首次登录 developerWorks 时,会为您创建一份个人概要。您的个人概要中的信息(您的姓名、国家/地区,以及公司名称)是公开显示的,而且会随着您发布的任何内容一起显示,除非您选择隐藏您的公司名称。您可以随时更新您的 IBM 帐户。

所有提交的信息确保安全。

选择您的昵称



当您初次登录到 developerWorks 时,将会为您创建一份概要信息,您需要指定一个昵称。您的昵称将和您在 developerWorks 发布的内容显示在一起。

昵称长度在 3 至 31 个字符之间。 您的昵称在 developerWorks 社区中必须是唯一的,并且出于隐私保护的原因,不能是您的电子邮件地址。

标有星(*)号的字段是必填字段。

(昵称长度在 3 至 31 个字符之间)

单击提交则表示您同意developerWorks 的条款和条件。 查看条款和条件.

 


所有提交的信息确保安全。


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=10
Zone=Java technology
ArticleID=966627
ArticleTitle=Java 下一代: 函数式编码风格
publish-date=03272014