第一章 你好，lambda表達(dá)式！

第一節(jié)

Java的編碼風(fēng)格正面臨著翻天覆地的變化。

我們每天的工作將會(huì)變成更簡(jiǎn)單方便，更富表現(xiàn)力。Java這種新的編程方式早在數(shù)十年前就已經(jīng)出現(xiàn)在別的編程語(yǔ)言里面了。這些新特性引入Java后，我們可以寫出更簡(jiǎn)潔，優(yōu)雅，表達(dá)性更強(qiáng)，錯(cuò)誤更少的代碼。我們可以用更少的代碼來(lái)實(shí)現(xiàn)各種策略和設(shè)計(jì)模式。

在本書中我們將通過日常編程中的一些例子來(lái)探索函數(shù)式風(fēng)格的編程。在使用這種全新的優(yōu)雅的方式進(jìn)行設(shè)計(jì)編碼之前，我們先來(lái)看下它到底好在哪里。

改變了你的思考方式

命令式風(fēng)格——Java語(yǔ)言從誕生之初就一直提供的是這種方式。使用這種風(fēng)格的話，我們得告訴Java每一步要做什么，然后看著它切實(shí)的一步步執(zhí)行下去。這樣做當(dāng)然很好，就是顯得有點(diǎn)初級(jí)。代碼看起來(lái)有點(diǎn)啰嗦，我們希望這個(gè)語(yǔ)言能變得稍微智能一點(diǎn)；我們應(yīng)該直接告訴它我們想要什么，而不是告訴它如何去做。好在現(xiàn)在Java終于可以幫我們實(shí)現(xiàn)這個(gè)愿望了。我們先來(lái)看幾個(gè)例子，了解下這種風(fēng)格的優(yōu)點(diǎn)和不同之處。

正常的方式

我們先從兩個(gè)熟悉的例子來(lái)開始。這是用命令的方式來(lái)查看芝加哥是不是指定的城市集合里——記住，本書中列出的代碼只是部分片段而已。

這個(gè)命令式的版本看起來(lái)有點(diǎn)啰嗦而且初級(jí)；它分成好幾個(gè)執(zhí)行部分。先是初始化一個(gè)叫found的布爾標(biāo)記，然后遍歷集合里的每一個(gè)元素；如果發(fā)現(xiàn)我們要找的城市了，設(shè)置下這個(gè)標(biāo)記，然后跳出循環(huán)體；最后打印出查找的結(jié)果。

一種更好的方式

細(xì)心的Java程序員看完這段代碼后，很快會(huì)想到一種更簡(jiǎn)潔明了的方式，就像這樣：

這也是一種命令式風(fēng)格的寫法——contains方法直接就幫我們搞定了。

實(shí)際改進(jìn)的地方

代碼這么寫有這幾個(gè)好處：

1.不用再搗鼓那個(gè)可變的變量了
2.將迭代封裝到了底層
3.代碼更簡(jiǎn)潔
4.代碼更清晰，更聚焦
5.少走彎路，代碼和業(yè)務(wù)需求結(jié)合更密切
6.不易出錯(cuò)
7.易于理解和維護(hù)

來(lái)個(gè)復(fù)雜點(diǎn)的例子

這個(gè)例子太簡(jiǎn)單了，命令式查詢一個(gè)元素是否存在于某個(gè)集合在Java里隨處可見?，F(xiàn)在假設(shè)我們要用命令式編程來(lái)進(jìn)行些更高級(jí)的操作，比如解析文件 ，和數(shù)據(jù)庫(kù)交互，調(diào)用WEB服務(wù)，并發(fā)編程等等?，F(xiàn)在我們用Java可以寫出更簡(jiǎn)潔優(yōu)雅同時(shí)出錯(cuò)更少的代碼，更不只是這種簡(jiǎn)單的場(chǎng)景。

老的方式

我們來(lái)看下另一個(gè)例子。我們定義了一系列價(jià)格，并通過不同的方式來(lái)計(jì)算打折后的總價(jià)。

假設(shè)超過20塊的話要打九折，我們先用普通的方式實(shí)現(xiàn)一遍。

這個(gè)代碼很熟悉吧；先用一個(gè)變量來(lái)存儲(chǔ)總價(jià)；然后遍歷所有的價(jià)格，找出大于20塊的，算出它們的折扣價(jià)，并加到總價(jià)里面；最后打印出折扣后的總價(jià)。

下面是程序的輸出：

結(jié)果完全正確，不過這樣的代碼有點(diǎn)亂。這并不是我們的錯(cuò)，我們只能用已有的方式來(lái)寫。不過這樣的代碼實(shí)在有點(diǎn)初級(jí)，它不僅存在基本類型偏執(zhí)，而且還違反了單一職責(zé)原則。如果你是在家工作并且家里還有想當(dāng)碼農(nóng)的小孩的話，你可得把你的代碼藏好了，萬(wàn)一他們看見了會(huì)很失望地嘆氣道，“你是靠這些玩意兒糊口的？”

還有更好的方式

我們還能做的更好——并且要好很多。我們的代碼有點(diǎn)像需求規(guī)范。這樣能縮小業(yè)務(wù)需求和實(shí)現(xiàn)的代碼之間的差距，減少了需求被誤讀的可能性。

我們不再讓Java去創(chuàng)建一個(gè)變量然后沒完沒了的給它賦值了，我們要從一個(gè)更高層次的抽象去與它溝通，就像下面的這段代碼。

大聲的讀出來(lái)吧——過濾出大于20塊的價(jià)格，把它們轉(zhuǎn)化成折扣價(jià)，然后加起來(lái)。這段代碼和我們描述需求的流程簡(jiǎn)直一模一樣。Java里還可以很方便的把一行長(zhǎng)的代碼折疊起來(lái)，根據(jù)方法名前面的點(diǎn)號(hào)進(jìn)行按行對(duì)齊，就像上面那樣。

代碼非常簡(jiǎn)潔，不過我們用到了Java8里面的很多新東西。首先，我們調(diào)用 了價(jià)格列表的一個(gè)stream方法。這打開了一扇大門，門后邊有數(shù)不盡的便捷的迭代器，這個(gè)我們?cè)诤竺鏁?huì)繼續(xù)討論。

我們用了一些特殊的方法，比如filter和map，而不是直接的遍歷整個(gè)列表。這些方法不像我們以前用的JDK里面的那些，它們接受一個(gè)匿名的函數(shù)——lambda表達(dá)式——作為參數(shù)。（后面我們會(huì)深入的展開討論）。我們調(diào)用reduce()方法來(lái)計(jì)算map()方法返回的價(jià)格的總和。

就像contains方法那樣，循環(huán)體被隱藏起來(lái)了。不過map方法（以及filter方法）則更復(fù)雜得多 。它對(duì)價(jià)格列表中的每一個(gè)價(jià)格，調(diào)用了傳進(jìn)來(lái)的lambda表達(dá)式進(jìn)行計(jì)算，把結(jié)果放到一個(gè)新的集合里面。最后我們?cè)谶@個(gè)新的集合上調(diào)用 reduce方法得出最終的結(jié)果。

這是以上代碼的輸出結(jié)果：

改進(jìn)的地方

這和前面的實(shí)現(xiàn)相比改進(jìn)明顯：

1.結(jié)構(gòu)良好而不混亂
2.沒有低級(jí)操作
3.易于增強(qiáng)或者修改邏輯
4.由方法庫(kù)來(lái)進(jìn)行迭代
5.高效；循環(huán)體惰性求值
6.易于并行化

下面我們會(huì)說(shuō)到Java是如何實(shí)現(xiàn)這些的。

lambda表達(dá)式來(lái)拯救世界了

lambda表達(dá)式是讓我們遠(yuǎn)離命令式編程煩惱的快捷鍵。Java提供的這個(gè)新特性，改變了我們?cè)械木幊谭绞?，使得我們寫出的代碼不僅簡(jiǎn)潔優(yōu)雅，不易出錯(cuò)，而且效率更高，易于優(yōu)化改進(jìn)和并行化。

第二節(jié)：函數(shù)式編程的最大收獲

函數(shù)式風(fēng)格的代碼有更高的信噪比；寫的代碼更少了，但每一行或者每個(gè)表達(dá)式做的卻更多了。比命令式編程相比，函數(shù)式編程讓我們獲益良多：

避免了對(duì)變量的顯式的修改或賦值，這些通常是BUG的根源，并導(dǎo)致代碼很難并行化。在命令行編程中我們?cè)谘h(huán)體內(nèi)不停的對(duì)totalOfDiscountedPrices變量賦值。在函數(shù)式風(fēng)格里，代碼不再出現(xiàn)顯式的修改操作。變量修改的越少，代碼的BUG就越少。

函數(shù)式風(fēng)格的代碼可以輕松的實(shí)現(xiàn)并行化。如果計(jì)算很費(fèi)時(shí)，我們可以很容易讓列表中的元素并發(fā)的執(zhí)行。如果我們想把命令式的代碼并行化，我們還得擔(dān)心并發(fā)修改totalOfDiscountedPrices變量帶來(lái)的問題。在函數(shù)式編程中我們只會(huì)在完全處理完后才訪問這個(gè)變量，這樣就消除了線程安全的隱患。

代碼的表達(dá)性更強(qiáng)。命令式編程要分成好幾個(gè)步驟要說(shuō)明要做什么——?jiǎng)?chuàng)建一個(gè)初始化的值，遍歷價(jià)格，把折扣價(jià)加到變量上等等——而函數(shù)式的話只需要讓列表的map方法返回一個(gè)包括折扣價(jià)的新的列表然后進(jìn)行累加就可以了。
函數(shù)式編程更簡(jiǎn)潔；和命令式相比同樣的結(jié)果只需要更少的代碼就能完成。代碼更簡(jiǎn)潔意味著寫的代碼少了，讀的也少了，維護(hù)的也少了——看下第7頁(yè)的"簡(jiǎn)潔少就是簡(jiǎn)潔了嗎"。

函數(shù)式的代碼更直觀——讀代碼就像描述問題一樣——一旦我們熟悉語(yǔ)法后就很容易能看懂。map方法對(duì)集合的每個(gè)元素都執(zhí)行了一遍給定的函數(shù)（計(jì)算折扣價(jià)），然后返回結(jié)果集，就像下圖演示的這樣。

圖1——map對(duì)集合中的每個(gè)元素執(zhí)行給定的函數(shù)

有了lambda表達(dá)式之后，我們可以在Java里充分發(fā)揮函數(shù)式編程的威力。使用函數(shù)式風(fēng)格，就能寫出表達(dá)性更佳，更簡(jiǎn)潔，賦值操作更少，錯(cuò)誤更少的代碼了。
支持面向?qū)ο缶幊淌荍ava一個(gè)主要的優(yōu)點(diǎn)。函數(shù)式編程和面向?qū)ο缶幊滩⒉慌懦?。真正的風(fēng)格變化是從命令行編程轉(zhuǎn)到聲明式編程。在Java 8里，函數(shù)式和面向?qū)ο罂梢杂行У娜诤系揭黄?。我們可以繼續(xù)用OOP的風(fēng)格來(lái)對(duì)領(lǐng)域?qū)嶓w以及它們的狀態(tài)，關(guān)系進(jìn)行建模。除此之外，我們還可以對(duì)行為或者狀態(tài)的轉(zhuǎn)變，工作流和數(shù)據(jù)處理用函數(shù)來(lái)進(jìn)行建模，建立復(fù)合函數(shù)。

第三節(jié):為什么要用函數(shù)式風(fēng)格？

我們看到了函數(shù)式編程的各項(xiàng)優(yōu)點(diǎn)，不過使用這種新的風(fēng)格劃得來(lái)嗎？這只是個(gè)小改進(jìn)還是說(shuō)換頭換面？在真正在這上面花費(fèi)工夫前，還有很多現(xiàn)實(shí)的問題需要解答。

用Java寫代碼并不難，語(yǔ)法簡(jiǎn)單。而且我們也已經(jīng)對(duì)現(xiàn)有的庫(kù)和API很了如指掌了。真正難的是要拿它來(lái)開發(fā)和維護(hù)企業(yè)級(jí)的應(yīng)用。

我們要確保同事在正確的時(shí)間關(guān)閉了數(shù)據(jù)庫(kù)連接，還有他們不會(huì)不停的占有事務(wù)，能在合適的分層上正確的處理好異常，能正確的獲得和釋放鎖，等等。

這些問題任何一個(gè)單獨(dú)來(lái)看都不是什么大事。不過如果和領(lǐng)域內(nèi)的復(fù)雜性一結(jié)合的話，問題就變得很棘手了，開發(fā)資源緊張，難以維護(hù)。

如果把這些策略封裝成許多小塊的代碼，讓它們各自進(jìn)行約束管理的話，會(huì)怎么樣呢？那我們就不用再不停的花費(fèi)精力去實(shí)施策略了。這是個(gè)巨大的改進(jìn)， 我們來(lái)看下函數(shù)式編程是如何做到的。

瘋狂的迭代

我們一直都在寫各種迭代來(lái)處理列表，集合，還有map。在Java里使用迭代器再常見不過了，不過這太復(fù)雜了。它們不僅占用了好幾行代碼，還很難進(jìn)行封裝。

我們是如何遍歷集合并打印它們的？可以使用一個(gè)for循環(huán)。我們?cè)趺磸募侠镞^濾出一些元素？還是用for循環(huán)，不過還需要額外增加一些可修改的變量。選出了這些值后，怎么用它們求出最終值，比如最小值，最大值，平均值之類的？那還得再循環(huán)，再修改變量。

這樣的迭代就是個(gè)萬(wàn)金油，啥都會(huì)點(diǎn)，但樣樣稀松?，F(xiàn)在Java為許多操作都專門提供了內(nèi)建的迭代器：比如只做循環(huán)的，還有做map操作的，過濾值的，做reduce操作的，還有許多方便的函數(shù)比如 最大最小值，平均值等等。除此之外，這些操作還可以很好的組合起來(lái)，因此我們可以將它們拼裝到一起來(lái)實(shí)現(xiàn)業(yè)務(wù)邏輯，這樣做既簡(jiǎn)單代碼量也少。而且寫出來(lái)的代碼可讀性強(qiáng)，因?yàn)樗鼜倪壿嬌虾兔枋鰡栴}的順序是一致的。我們?cè)诘诙拢系氖褂?，?9頁(yè)會(huì)看到幾個(gè)這樣的例子，這本書里這樣的例子也比比皆是。

應(yīng)用策略

策略貫穿于整個(gè)企業(yè)級(jí)應(yīng)用中。比如，我們需要確認(rèn)某個(gè)操作已經(jīng)正確的進(jìn)行了安全認(rèn)證，我們要保證事務(wù)能夠快速執(zhí)行，并且正確的更新修改日志。這些任務(wù)通常最后就變成服務(wù)端的一段普通的代碼，就跟下面這個(gè)偽代碼差不多：

這種處理方法有兩個(gè)問題。首先，它通常導(dǎo)致了重復(fù)的工作量并且還增加了維護(hù)的成本。第二，很容易忘了業(yè)務(wù)代碼中可能會(huì)被拋出來(lái)的異常，可能會(huì)影響到事務(wù)的生命周期和修改日志的更新。這里應(yīng)該使用try, finally塊來(lái)實(shí)現(xiàn)，不過每當(dāng)有人動(dòng)了這塊代碼，我們又得重新確認(rèn)這個(gè)策略沒有被破壞。

還有一種方法，我們可以去掉工廠，把這段代碼放在它前面。不用再獲取事務(wù)對(duì)象，而是把執(zhí)行的代碼傳給一個(gè)維護(hù)良好的函數(shù)，就像這樣：

這是你的一小步，但是省了一大堆事。檢查狀態(tài)同時(shí)更新日志的這個(gè)策略被抽象出來(lái)封裝到了runWithinTransaction方法里。我們給這個(gè)方法發(fā)送一段需要在事務(wù)上下文里運(yùn)行的代碼。我們不用再擔(dān)心誰(shuí)忘了執(zhí)行這個(gè)步驟或者沒有處理好異常。這個(gè)實(shí)施策略的函數(shù)已經(jīng)把這事搞定了。

我們將會(huì)在第五章中介紹如果使用lambda表達(dá)式來(lái)應(yīng)用這樣的策略。

擴(kuò)展策略

策略看起來(lái)無(wú)處不在。除了要應(yīng)用它們外，企業(yè)級(jí)應(yīng)用還需要對(duì)它們進(jìn)行擴(kuò)展。我們希望能通過一些配置信息來(lái)增加或者刪除一些操作，換言之，就是能在模塊的核心邏輯執(zhí)行前進(jìn)行處理。這在Java里很常見，不過需要預(yù)先考慮到并設(shè)計(jì)好。

需要擴(kuò)展的組件通常有一個(gè)或者多個(gè)接口。我們需要仔細(xì)設(shè)計(jì)接口以及實(shí)現(xiàn)類的分層結(jié)構(gòu)。這樣做可能效果很好，但是會(huì)留下一大堆需要維護(hù)的接口和類。這樣的設(shè)計(jì)很容易變得笨重且難以維護(hù)，最終破壞擴(kuò)展的初衷。

還有一種解決方法——函數(shù)式接口，以及l(fā)ambda表達(dá)式，我們可以用它們來(lái)設(shè)計(jì)可擴(kuò)展的策略。我們不用非得創(chuàng)建新的接口或者都遵循同一個(gè)方法名，可以更聚焦要實(shí)現(xiàn)的業(yè)務(wù)邏輯，我們會(huì)在73頁(yè)的使用lambda表達(dá)式進(jìn)行裝飾中提到。

輕松實(shí)現(xiàn)并發(fā)

一個(gè)大型應(yīng)用快到了發(fā)布里程碑的時(shí)候，突然一個(gè)嚴(yán)重的性能問題浮出水面。團(tuán)隊(duì)迅速定位出性能瓶頸點(diǎn)是出在一個(gè)處理海量數(shù)據(jù)的龐大的模塊里。團(tuán)隊(duì)中有人建議說(shuō)如果能充分發(fā)掘多核的優(yōu)勢(shì)的話可以提高系統(tǒng)性能。不過如果這個(gè)龐大的模塊是用老的Java風(fēng)格寫的話，剛才這個(gè)建議帶來(lái)的喜悅很快就破滅了。

團(tuán)隊(duì)很快意識(shí)到要這把這個(gè)龐然大物從串行執(zhí)行改成并行需要費(fèi)很大的精力，增加了額外的復(fù)雜度，還容易引起多線程相關(guān)的BUG。難道沒有一種提高性能的更好方式嗎？
有沒有可能串行和并行的代碼都是一樣的，不管選擇串行還是并行執(zhí)行，就像按一下開關(guān)，表明一下想法就可以了？

聽起來(lái)好像只有納尼亞里面能這樣，不過如果我們完全用函數(shù)式進(jìn)行開發(fā)的話，這一切都將成為現(xiàn)實(shí)。內(nèi)置的迭代器和函數(shù)式風(fēng)格將掃清通往并行化的最后一道障礙。JDK的設(shè)計(jì)使得串行和并行執(zhí)行的切換只需要一點(diǎn)不起眼的代碼改動(dòng)就可以實(shí)現(xiàn)，我們將會(huì)在145頁(yè)《完成并行化的飛躍》中提到。

講故事

在業(yè)務(wù)需求變成代碼實(shí)現(xiàn)的過程中會(huì)丟失大量的東西。丟失的越多，出錯(cuò)的可能性和管理的成本就越高。如果代碼看起來(lái)就跟描述需求一樣，將會(huì)很方便閱讀，和需求人員討論也變的更簡(jiǎn)單，也更容易滿足他們的需求。

比如你聽到產(chǎn)品經(jīng)理在說(shuō)，”拿到所有股票的價(jià)格，找出價(jià)格大于500塊的，計(jì)算出能分紅的資產(chǎn)總和”。使用Java提供的新設(shè)施，可以這么寫：

這個(gè)轉(zhuǎn)化過程幾乎是無(wú)損的，因?yàn)榛旧弦矝]什么要轉(zhuǎn)化的。這是函數(shù)式在發(fā)揮作用，在本書中還會(huì)看到更多這樣的例子，尤其是第8章，使用lambda表達(dá)式來(lái)構(gòu)建程序，137頁(yè)。

關(guān)注隔離

在系統(tǒng)開發(fā)中，核心業(yè)務(wù)和它所需要的細(xì)粒度邏輯通常需要進(jìn)行隔離。比如說(shuō)，一個(gè)訂單處理系統(tǒng)想要對(duì)不同的交易來(lái)源使用不同的計(jì)稅策略。把計(jì)稅和其余的處理邏輯進(jìn)行隔離會(huì)使得代碼重用性和擴(kuò)展性更高。

在面向?qū)ο缶幊讨形覀儼堰@個(gè)稱之為關(guān)注隔離，通常用策略模式來(lái)解決這個(gè)問題。解決方法一般就是創(chuàng)建一些接口和實(shí)現(xiàn)類。

我們可以用更少的代碼來(lái)完成同樣的效果。我們還可以快速嘗試自己的產(chǎn)品思路，而不用上來(lái)就得搞出一堆代碼，停滯不前。我們將在63頁(yè)的，使用lambda表達(dá)式進(jìn)行關(guān)注隔離中進(jìn)一步探討如果通過輕量級(jí)函數(shù)來(lái)創(chuàng)建這種模式以及進(jìn)行關(guān)注隔離。

惰性求值

開發(fā)企業(yè)級(jí)應(yīng)用時(shí)，我們可能會(huì)與WEB服務(wù)進(jìn)行交互，調(diào)用數(shù)據(jù)庫(kù)，處理XML等等。我們要執(zhí)行的操作有很多，不過并不是所有時(shí)候都全部需要。避免某些操作或者至少延遲一些暫時(shí)不需要的操作是提高性能或者減少程序啟動(dòng)，響應(yīng)時(shí)間的一個(gè)最簡(jiǎn)單的方式。

這只是個(gè)小事，但用純OOP的方式來(lái)實(shí)現(xiàn)還需要費(fèi)一番工夫。為了延遲一些重量級(jí)對(duì)象的初始化，我們要處理各種對(duì)象引用 ，檢查空指針等等。

不過，如果使用了新的Optinal類和它提供的一些函數(shù)式風(fēng)格的API，這個(gè)過程將變得很簡(jiǎn)單，代碼也更清晰明了，我們會(huì)在105頁(yè)的延遲初始化中討論這個(gè)。

提高可測(cè)性

代碼的處理邏輯越少，容易被改錯(cuò)的地方當(dāng)然也越少。一般來(lái)說(shuō)函數(shù)式的代碼比較容易修改，測(cè)試起來(lái)也較簡(jiǎn)單。

另外，就像第4章，使用lambda表達(dá)式進(jìn)行設(shè)計(jì)和第5章資源的使用中那樣，lambda表達(dá)式可以作為一種輕量級(jí)的mock對(duì)象，讓異常測(cè)試變得更清晰易懂。lambda表達(dá)式還可以作為一個(gè)很好的測(cè)試輔助工具。很多常見的測(cè)試用例都可以接受并處理lambda表達(dá)式。這樣寫的測(cè)試用例能夠抓住需要回歸測(cè)試的功能的本質(zhì)。同時(shí)，需要測(cè)試的各種實(shí)現(xiàn)都可以通過傳入不同的lambda表達(dá)式來(lái)完成。
JDK自己的自動(dòng)化測(cè)試用例也是lambda表達(dá)式的一個(gè)很好的應(yīng)用范例——想了解更多的話可以看下OpenJDK倉(cāng)庫(kù)里的源代碼。通過這些測(cè)試程序可以看到lambda表達(dá)式是如何將測(cè)試用例的關(guān)鍵行為進(jìn)行參數(shù)化；比如，它們是這樣構(gòu)建測(cè)試程序的，“新建一個(gè)結(jié)果的容器”，然后“對(duì)一些參數(shù)化的后置條件進(jìn)行檢查”。

我們已經(jīng)看到，函數(shù)式編程不僅能讓我們寫出高質(zhì)量的代碼，還能優(yōu)雅的解決開發(fā)過程中的各種難題。這就是說(shuō)，開發(fā)程序?qū)⒆兊酶旄?jiǎn)單，出錯(cuò)也更少——只要你能遵守我們后面將要介紹到的幾條準(zhǔn)則。

第四節(jié)：進(jìn)化而非革命

我們用不著轉(zhuǎn)向別的語(yǔ)言，就能享受函數(shù)式編程帶來(lái)的好處；需要改變的只是使用Java的一些方式。C++，Java，C#這些語(yǔ)言都支持命令式和面向?qū)ο蟮木幊?。不過現(xiàn)在它們都開始投入函數(shù)式編程的懷抱里了。我們剛才已經(jīng)看到了這兩種風(fēng)格的代碼，并討論了函數(shù)式編程能帶來(lái)的好處?，F(xiàn)在我們來(lái)看下它的一些關(guān)鍵概念和例子來(lái)幫助我們學(xué)習(xí)這種新的風(fēng)格。

Java語(yǔ)言的開發(fā)團(tuán)隊(duì)花費(fèi)了大量的時(shí)間和精力把函數(shù)式編程的能力添加到了Java語(yǔ)言和JDK里。要享受它帶來(lái)的好處，我們得先介紹幾個(gè)新的概念。我們只要遵循下面幾條規(guī)則就能提升我們的代碼質(zhì)量：

1.聲明式
2.提倡不可變性
3.避免副作用
4.優(yōu)先使用表達(dá)式而不是語(yǔ)句
5.使用高階函數(shù)進(jìn)行設(shè)計(jì)

我們來(lái)看下這幾條實(shí)踐準(zhǔn)則。

聲明式

我們所熟悉的命令式編程的核心就是可變性和命令驅(qū)動(dòng)的編程。我們創(chuàng)建變量，然后不斷修改它們的值。我們還提供了要執(zhí)行的詳細(xì)的指令，比如生成迭代的索引標(biāo)志，增加它的值，檢查循環(huán)是否結(jié)束，更新數(shù)組的第N個(gè)元素等。在過去由于工具的特性和硬件的限制，我們只能這么寫代碼。 我們也看到了，在一個(gè)不可變集合上，聲明式的contains方法比命令式的更容易使用。所有的難題和低級(jí)的操作都在庫(kù)函數(shù)里來(lái)實(shí)現(xiàn)了，我們不用再關(guān)心這些細(xì)節(jié)。就沖著簡(jiǎn)單這點(diǎn)，我們也應(yīng)該使用聲明式編程。不可變性和聲明式編程是函數(shù)式編程的精髓，現(xiàn)在Java終于把它變成了現(xiàn)實(shí)。

提倡不可變性

變量可變的代碼會(huì)有很多活動(dòng)路徑。改的東西越多，越容易破壞原有的結(jié)構(gòu)，并引入更多的錯(cuò)誤。有多個(gè)變量被修改的代碼難于理解也很難進(jìn)行并行化。不可變性從根本上消除了這些煩惱。 Java支持不可變性但沒有強(qiáng)制要求——但我們可以。我們需要改變修改對(duì)象狀態(tài)這個(gè)舊習(xí)慣。我們要盡可能的使用不可變的對(duì)象。 聲明變量，成員和參數(shù)的時(shí)候，盡量聲明為final的，就像Joshua Bloch在” Effective Java“里說(shuō)的那句名言那樣，“把對(duì)象當(dāng)成不可變的吧”。 當(dāng)創(chuàng)建對(duì)象的時(shí)候，盡量創(chuàng)建不可變的對(duì)象，比如String這樣的。創(chuàng)建集合的時(shí)候，也盡量創(chuàng)建不可變或者無(wú)法修改的集合，比如用Arrays.asList()和Collections的unmodifiableList()這樣的方法。 避免了可變性我們才可以寫出純粹的函數(shù)——也就是，沒有副作用的函數(shù)。

避免副作用

假設(shè)你在寫一段代碼到網(wǎng)上去抓取一支股票的價(jià)格然后寫到一個(gè)共享變量里。如果我們有很多價(jià)格要抓取，我們得串行的執(zhí)行這些費(fèi)時(shí)的操作。如果我們想借助多線程的能力，我們得處理線程和同步帶來(lái)的麻煩事，防止出現(xiàn)競(jìng)爭(zhēng)條件。最后的結(jié)果是程序的性能很差，為了維護(hù)線程而廢寢忘食。如果消除了副作用，我們完全可以避免這些問題。 沒有副作用的函數(shù)推崇的是不可變性，在它的作用域內(nèi)不會(huì)修改任何輸入或者別的東西。這種函數(shù)可讀性強(qiáng)，錯(cuò)誤少，容易優(yōu)化。由于沒有副作用，也不用再擔(dān)心什么競(jìng)爭(zhēng)條件或者并發(fā)修改了。不僅如此，我們還可以很容易并行執(zhí)行這些函數(shù)，我們將在145頁(yè)的來(lái)討論這個(gè)。

優(yōu)先使用表達(dá)式

語(yǔ)句是個(gè)燙手的山芋，因?yàn)樗鼜?qiáng)制進(jìn)行修改。表達(dá)式提升了不可變性和函數(shù)組合的能力。比如，我們先用for語(yǔ)句計(jì)算折扣后的總價(jià)。這樣的代碼導(dǎo)致了可變性以及冗長(zhǎng)的代碼。使用map和sum方法的表達(dá)性更強(qiáng)的聲明式的版本后，不僅避免了修改操作，同時(shí)還能把函數(shù)串聯(lián)起來(lái)。 寫代碼的時(shí)候應(yīng)該盡量使用表達(dá)式，而不是語(yǔ)句。這樣使得代碼更簡(jiǎn)潔易懂。代碼會(huì)順著業(yè)務(wù)邏輯執(zhí)行，就像我們描述問題的時(shí)候那樣。如果需求變動(dòng)，簡(jiǎn)潔的版本無(wú)疑更容易修改。

使用高階函數(shù)進(jìn)行設(shè)計(jì)

Java不像Haskell那些函數(shù)式語(yǔ)言那樣強(qiáng)制要求不可變，它允許我們修改變量。因此，Java不是，也永遠(yuǎn)不會(huì)是，一個(gè)純粹的函數(shù)式編程語(yǔ)言。然而，我們可以在Java里使用高階函數(shù)進(jìn)行函數(shù)式編程。 高階函數(shù)使得重用更上一層樓。有了高階函數(shù)我們可以很方便的重用那些小而專，內(nèi)聚性強(qiáng)的成熟的代碼。 在OOP中我們習(xí)慣了給方法傳遞給對(duì)象，在方法里面創(chuàng)建新的對(duì)象，然后返回對(duì)象。高階函數(shù)對(duì)函數(shù)做的事情就跟方法對(duì)對(duì)象做的一樣。有了高階函數(shù)我們可以。

1.把函數(shù)傳給函數(shù)
2.在函數(shù)內(nèi)創(chuàng)建新的函數(shù)
3.在函數(shù)內(nèi)返回函數(shù)

我們已經(jīng)見過一個(gè)把函數(shù)傳參給另一個(gè)函數(shù)的例子了，在后面我們還會(huì)看到創(chuàng)建函數(shù)和返回函數(shù)的示例。我們先再看一遍“把函數(shù)傳參給函數(shù)”的那個(gè)例子：

在這段代碼中我們把函數(shù)price -> price.multiply(BigDecimal.valueOf(0.9)),傳給了map函數(shù)。傳遞的這個(gè)函數(shù)是在調(diào)用高階函數(shù)map的時(shí)候才創(chuàng)建的。通常來(lái)說(shuō)一個(gè)函數(shù)有函數(shù)體，函數(shù)名，參數(shù)列表，返回值。這個(gè)實(shí)時(shí)創(chuàng)建的函數(shù)有一個(gè)參數(shù)列表后面跟著一個(gè)箭頭（->），然后就是很短的一段函數(shù)體了。參數(shù)的類型由Java編譯器來(lái)進(jìn)行推導(dǎo)，返回的類型也是隱式的。這是個(gè)匿名函數(shù)，它沒有名字。不過我們不叫它匿名函數(shù)，我們稱之為lambda表達(dá)式。 匿名函數(shù)作為傳參在Java并不算是什么新鮮事；我們之前也經(jīng)常傳遞匿名內(nèi)部類。即使匿名類只有一個(gè)方法，我們還是得走一遍創(chuàng)建類的儀式，然后對(duì)它進(jìn)行實(shí)例化。有了lambda表達(dá)式我們可以享受輕量級(jí)的語(yǔ)法了。不僅如此，我們之前總是習(xí)慣把一些概念抽象成各種對(duì)象，現(xiàn)在我們可以將一些行為抽象成lambda表達(dá)式了。 用這種編碼風(fēng)格進(jìn)行程序設(shè)計(jì)還是需要費(fèi)些腦筋的。我們得把已經(jīng)根深蒂固的命令式思維轉(zhuǎn)變成函數(shù)式的。開始的時(shí)候可能有點(diǎn)痛苦，不過很快你就會(huì)習(xí)慣它了，隨著不斷的深入，那些非函數(shù)式的API逐漸就被拋到腦后了。 這個(gè)話題就先到這吧，我們來(lái)看看Java是如何處理lambda表達(dá)式的。我們之前總是把對(duì)象傳給方法，現(xiàn)在我們可以把函數(shù)存儲(chǔ)起來(lái)并傳遞它們。 我們來(lái)看下Java能夠?qū)⒑瘮?shù)作為參數(shù)背后的秘密。

第五節(jié)：加了點(diǎn)語(yǔ)法糖

用Java原有的功能也是可以實(shí)現(xiàn)這些的，不過lambda表達(dá)式加了點(diǎn)語(yǔ)法糖，省掉了一些步驟，使我們的工作更簡(jiǎn)單了。這樣寫出的代碼不僅開發(fā)更快，也更能表達(dá)我們的想法。 過去我們用的很多接口都只有一個(gè)方法：像Runnable, Callable等等。這些接口在JDK庫(kù)中隨處可見，使用它們的地方通常用一個(gè)函數(shù)就能搞定。原來(lái)的這些只需要一個(gè)單方法接口的庫(kù)函數(shù)現(xiàn)在可以傳遞輕量級(jí)函數(shù)了，多虧了這個(gè)通過函數(shù)式接口提供的語(yǔ)法糖。 函數(shù)式接口是只有一個(gè)抽象方法的接口。再看下那些只有一個(gè)方法的接口，Runnable,Callable等，都適用這個(gè)定義。JDK8里面有更多這類的接口——Function, Predicate, Comsumer, Supplier等（157頁(yè)，附錄1有更詳細(xì)的接口列表）。函數(shù)式接口可以有多個(gè)static方法，和default方法，這些方法是在接口里面實(shí)現(xiàn)的。 我們可以用@FunctionalInterface注解來(lái)標(biāo)注一個(gè)函數(shù)式接口。編譯器不使用這個(gè)注解，不過有了它可以更明確的標(biāo)識(shí)這個(gè)接口的類型。不止如此，如果我們用這個(gè)注解標(biāo)注了一個(gè)接口，編譯器會(huì)強(qiáng)制校驗(yàn)它是否符合函數(shù)式接口的規(guī)則。 如果一個(gè)方法接收函數(shù)式接口作為參數(shù)，我們可以傳遞的參數(shù)包括：

1.匿名內(nèi)部類，最古老的方式
2.lambda表達(dá)式，就像我們?cè)趍ap方法里那樣
3.方法或者構(gòu)造器的引用（后面我們會(huì)講到）

如果方法的參數(shù)是函數(shù)式接口的話，編譯器會(huì)很樂意接受lambda表達(dá)式或者方法引用作為參數(shù)。 如果我們把一個(gè)lambda表達(dá)式傳遞給一個(gè)方法，編譯器會(huì)先把這個(gè)表達(dá)式轉(zhuǎn)化成對(duì)應(yīng)的函數(shù)式接口的一個(gè)實(shí)例。這個(gè)轉(zhuǎn)化可不止是生成一個(gè)內(nèi)部類而已。同步生成的這個(gè)實(shí)例的方法對(duì)應(yīng)于參數(shù)的函數(shù)式接口的抽象方法。比如，map方法接收函數(shù)式接口Function作為參數(shù)。在調(diào)用map方法時(shí)，java編譯器會(huì)同步生成它，就像下圖所示的一樣。

lambda表達(dá)式的參數(shù)必須和接口的抽象方法的參數(shù)匹配。這個(gè)生成的方法將返回lambda表達(dá)式的結(jié)果。如果返回類型不直接匹配抽象方法的話，這個(gè)方法會(huì)把返回值轉(zhuǎn)化成合適的類型。 我們已經(jīng)大概了解了下lambda表達(dá)式是如何傳遞給方法的。我們先來(lái)快速回顧一下剛講的內(nèi)容，然后開始我們lambda表達(dá)式的探索之旅。

總結(jié)

這是Java一個(gè)全新的領(lǐng)域。通過高階函數(shù)，我們現(xiàn)在可以寫出優(yōu)雅流利的函數(shù)式風(fēng)格的代碼了。這樣寫出的代碼，簡(jiǎn)潔易懂，錯(cuò)誤少，利于維護(hù)和并行化。Java編譯器發(fā)揮了它的魔力，在接收函數(shù)式接口參數(shù)的地方，我們可以傳入lambda表達(dá)式或者方法引用。 我們現(xiàn)在可以進(jìn)入lambda表達(dá)式以及為之改造的JDK庫(kù)的世界來(lái)感覺它們的樂趣了。在下一章中，我們將從編程里面最常見的集合操作開始，發(fā)揮lambda表達(dá)式的威力。

最新評(píng)論