函數式程式設計思維在三行代碼情書中的應用

函數式程式設計概述

如今主流的程式設計語言，函數式程式設計範式或多或少都融入其中成了“标配”，或者說主流語言都在進行函數式方面的擴充，這是一個大趨勢。以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") );
}           

後記

作者更多的原創文章：

在雲栖社群

文中提到的Groovy動态程式設計語言，作者體驗過一點，可以參考：

如果有興趣，也來看看作者一些關于容器化、微服務化方面的文章：

• RPC架構實踐之：Apache Thrift
• 微服務調用鍊追蹤中心搭建
• 利用K8S技術棧打造個人私有雲連載文章
• Docker容器可視化監控中心搭建
• 利用ELK搭建Docker容器化應用日志中心
• Spring Boot應用監控實戰