函数式编程思惟在三行代码情书中的应用

函数式编程概述

现在主流的编程语言，函数式编程范式或多或少都融入其中成了“标配”，或者说主流语言都在进行函数式方面的扩充，这是一个大趋势。以Java为例，随着 Lambda块 和 Stream API 等这种高阶函数的加持，Java总算是装备了函数式这一利器；博大精深的C++也在2011版的语言标准里加入了Lambda块的支持；再好比前一段时间我初步体验了的 Groovy语言，虽然其运行于JVM之上，然而其对 动态语言、函数式编程范式 以及 元编程功能 的加持所带来的表现力和简洁性能够说甩了Java几条街，能够利用Groovy的全部动态功能构建高性能的JVM应用、将开发效率提升几个数量级。语言的例子有不少，我不一一枚举。

为何要使用函数式编程范式

这里讲几个函数式编程的典型特色，区别的对象那就是传统的命令式编程

0x01. 更高层次的抽象（高阶函数）
用高阶抽象来取代基本的控制结构自己就是一个全新的思考方式，这样可让开发者聚焦精力于业务场景而无需费心复杂地层运做

举个栗子：将一个字符串集合中的全部单词转为大写，咱们用Java语言来实现

若是按照传统的命令式编程的解法，那接下来不出意外咱们得来写循环、遍历这种迭代操做了：

for (int i=0; i<wordList.size(); i++) {
   wordList.get(i).toUpperCase();
}

但若是使用Java的函数式编程范式，一切都是那么的优雅，一句话搞定

wordList.stream.map( w -> w.toUpperCase() )

这里的map()函数就是所谓的高阶函数，咱们用高阶函数代替了底层的迭代，由于咱们并无处理细节，咱们仅仅定义了映射的逻辑，迭代由高阶函数来自动完成！

0x02. 提高代码信噪比（简洁性）
区别于面向对象语言用抽象来封装不肯定因素，函数式编程经过尽可能减小不肯定因素来使代码极度简洁

上面的例子对于本条优势的展示我想应该也没必要多说了

0x03. 控制权转交于运行时（动态性）
区别于传统的编译形语言，配备函数式编程范式的动态语言更多的将控制权转交到语言运行时手里，得到的则是更高的灵活性、表现力和性能权衡。

这三点优势将在接下来的例子中切实的感觉并领会！

函数式编程例析

举例1：词频统计
作的事情很简单：给定一个单词集合，统计出集合中除了助词（如of、on、the等）以外的单词出现的频次，不区分大小写

命令式解法： 至少分为如下几大步

• 先进行循环迭代
• 而后统一将单词转为小写
• 而后判断单词是不是助词

• 最后进行词频统计

  public class WordCount {

  // 定义一个助词集合，这些单词不参与计数
     private Set<String> auxiliaryWordSet = new HashSet<String>() {{
        add("of"); add("the"); add("to"); add("and"); add("so"); add("are");
     }};
  
     // 传统命令式解法实现的词频统计函数
     public Map doWordCount( List<String> context ) {
         Map<String,Integer> result = new HashMap<String, Integer>();
         for ( String word:context ) {  // 循环迭代
             String lowerCaseWord = word.toLowerCase();  // 将单词统一转换为小写
             if( !auxiliaryWordSet.contains(lowerCaseWord) ) {
                 if( null == result.get(lowerCaseWord) )
                     result.put( lowerCaseWord, 1 );
                 else
                     result.put( lowerCaseWord, result.get(lowerCaseWord)+1 );
             }
         }
         return result;
     }
  
     // main() 函数
     public static void main(String[] args) {
         List<String> wordList = new ArrayList<String>() {{
             add("The"); add("Products"); add("of"); add("Samsung"); add("and"); add("Apple");
             add("are"); add("so"); add("amazing"); add("especially"); add("Apple");
         }};
  
         WordCount wordCount = new WordCount();
         Map res = wordCount.doWordCount( wordList );
         System.out.print(res); // 打印：{apple=2, amazing=1, samsung=1, especially=1, products=1}
     }

  }

函数式解法：

若是咱们用Java的Stream API和Lambda块所构成的函数式范式来重写 doWordCount() 函数，一切都将如此简洁：

public Map doWordCount2( List<String> context ) {
    Map<String,Integer> result = new HashMap<String, Integer>();
    context.stream().map( w -> w.toLowerCase() )
            .filter( w -> !auxiliaryWordSet.contains(w) )
            .forEach( w -> result.put( w, result.getOrDefault(w,0) + 1 ) );
    return result;
}

备注：这里的getOrDefault是Java的Map提供的一个便利函数，意思是：在Map中若没有找到给定的key时，返回一个“默认值”

对比命令式解法，用户省去了不少繁琐的迭代和判断，咱们只讲焦点聚焦在业务逻辑之上，代码信噪比提高不小吧！

举例2：连词成句
给定一个离散的单词集合，咱们想将字母数大于1的单词的首字母大写后，用 短横线- 链接起来成为一个句子

命令式解法：

public class WordConnect {

// 将单词的首字母大写
public String capitalizeFirstLetter( String s ) {
    return s.substring(0,1).toUpperCase() + s.substring(1,s.length() );
}

// 连词成句
public String connectWord( List<String> context ) {
    StringBuilder result = new StringBuilder();
    for ( String word: context ) {
        if ( word.length() > 1 ) {
            result.append( capitalizeFirstLetter(word) );
            result.append("-");
        }
    }
    return result.substring(0,result.length()-1).toString();
}

// main()函数
public static void main(String[] args) {
    List<String> wordList = new ArrayList<String>() {{
        add("The"); add("Products"); add("of"); add("Samsung"); add("and"); add("Apple");
        add("are"); add("so"); add("amazing"); add("especially"); add("Apple");
    }};

    WordConnect wordConnect = new WordConnect();
    String res = wordConnect.connectWord( wordList );
    System.out.print(res); // 打印：The-Products-Of-Samsung-And-Apple-Are-So-Amazing-Especially-Apple
}

}

函数式解法1： Java Steam API 和 Lambda块实现

public String connectWord( List<String> context ) {
    return context.stream().filter( w -> w.length()>1 )
            .map( w -> capitalizeFirstLetter(w) )
            .collect( Collectors.joining("-") );
}

我什么都不想说了，这不要太简洁好吧！

函数式解法2： Groovy语言实现

public String connectWord( context ) {
        context.findAll { it.length() >1 }
        .collect { it.capitalize() }
        .join '-'
    }

关于Groovy语言的初体验，能够参考个人文章：Groovy初体验：构建高性能JVM应用

函数式最佳实践：高效编写三行情书
还记得去年的520，为了表达心中对于老婆无限的、没法表达的爱，我想写一封不超过三行的代码情书，我更想用尽量短的代码来尽量多地表达，因而我选择了函数式编程。

个人520三行代码情书在此：

public TimeRiver timeFlow( List<DaysMeetYou> days ) {
    return (TimeRiver)days.stream()
        .filter( n->theDaysNotWithYou(n) )
        .map( e->accompanyByMyLove(e) )
        .collect( Collectors.joining("LOVE") );
}

个人520三行代码情书

本文做者：codesheep

阅读原文

本文为云栖社区原创内容，未经容许不得转载