在java8 里面Lambda是最火的主題，不僅僅是因?yàn)檎Z法的改變，更重要的是帶來了函數(shù)式編程的思想，我覺得優(yōu)秀的程序員，有必要學(xué)習(xí)一下函數(shù)式編程的思想以開闊思路。所以這篇文章聊聊Lambda的應(yīng)用場景，性能，也會提及下不好的一面。
Java為何需要Lambda
1996年1月，Java 1.0發(fā)布了，此后計(jì)算機(jī)編程領(lǐng)域發(fā)生了翻天覆地的變化。商業(yè)發(fā)展需要更復(fù)雜的應(yīng)用，大多數(shù)程序都跑在更強(qiáng)大的裝備多核CPU的機(jī)器上。帶有高效運(yùn)行期編譯器的Java虛擬機(jī)（JVM）的出現(xiàn)，使得程序員將精力更多放在編寫干凈、易于維護(hù)的代碼上，而不是思考如何將每一個CPU時鐘、每一字節(jié)內(nèi)存物盡其用。
多核CPU的出現(xiàn)成了“房間里的大象”，無法忽視卻沒人愿意正視。算法中引入鎖不但容易出錯，而且消耗時間。人們開發(fā)了java.util.concurrent包和很多第三方類庫，試圖將并發(fā)抽象化，用以幫助程序員寫出在多核CPU上運(yùn)行良好的程序。不幸的是，到目前為止，我們走得還不夠遠(yuǎn)。
那些類庫的開發(fā)者使用Java時，發(fā)現(xiàn)抽象的級別還不夠。處理大數(shù)據(jù)就是個很好的例子，面對大數(shù)據(jù)，Java還欠缺高效的并行操作。Java 8允許開發(fā)者編寫復(fù)雜的集合處理算法，只需要簡單修改一個方法，就能讓代碼在多核CPU上高效運(yùn)行。為了編寫并行處理這些大數(shù)據(jù)的類庫，需要在語言層面上修改現(xiàn)有的Java：增加lambda表達(dá)式。
當(dāng)然，這樣做是有代價(jià)的，程序員必須學(xué)習(xí)如何編寫和閱讀包含lambda表達(dá)式的代碼，但是，這不是一樁賠本的買賣。與手寫一大段復(fù)雜的、線程安全的代碼相比，學(xué)習(xí)一點(diǎn)新語法和一些新習(xí)慣容易很多。開發(fā)企業(yè)級應(yīng)用時，好的類庫和框架極大地降低了開發(fā)時間和成本，也掃清了開發(fā)易用且高效的類庫的障礙。
Lambda的應(yīng)用場景
下面我將重點(diǎn)放在函數(shù)式編程的實(shí)用性上，包括那些可以被大多數(shù)程序員理解和使用的技術(shù)，我們關(guān)心的如何寫出好代碼，而不是符合函數(shù)編程風(fēng)格的代碼。
1.1.1 1.使用() -> {} 替代匿名類
現(xiàn)在Runnable線程，Swing，JavaFX的事件監(jiān)聽器代碼等，在java 8中你可以使用Lambda表達(dá)式替代丑陋的匿名類。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
//Before Java 8:new Thread(new Runnable() { @Override public void run() { }}).start();//Java 8 way:new Thread(() -> System.out.println("In Java8!"));// Before Java 8:JButton show = new JButton("Show");show.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { System.out.println("without lambda expression is boring"); } });// Java 8 way:show.addActionListener((e) -> { System.out.println("Action !! Lambda expressions Rocks");}); |
使用內(nèi)循環(huán)替代外循環(huán)
外循環(huán)：描述怎么干，代碼里嵌套2個以上的for循環(huán)的都比較難讀懂；只能順序處理List中的元素；
內(nèi)循環(huán)：描述要干什么，而不是怎么干；不一定需要順序處理List中的元素
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
//Prior Java 8 :List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");for (String feature : features) { System.out.println(feature);}//In Java 8:List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");features.forEach(n -> System.out.println(n));// Even better use Method reference feature of Java 8// method reference is denoted by :: (double colon) operator// looks similar to score resolution operator of C++features.forEach(System.out::println);Output:LambdasDefault MethodStream APIDate and Time API |
支持函數(shù)編程
為了支持函數(shù)編程，Java 8加入了一個新的包java.util.function，其中有一個接口java.util.function.Predicate是支持Lambda函數(shù)編程：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public static void main(args[]){ List languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp"); System.out.println("Languages which starts with J :"); filter(languages, (str)->str.startsWith("J")); System.out.println("Languages which ends with a "); filter(languages, (str)->str.endsWith("a")); System.out.println("Print all languages :"); filter(languages, (str)->true); System.out.println("Print no language : "); filter(languages, (str)->false); System.out.println("Print language whose length greater than 4:"); filter(languages, (str)->str.length() > 4);} public static void filter(List names, Predicate condition) { names.stream().filter((name) -> (condition.test(name))) .forEach((name) -> {System.out.println(name + " "); }); } |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
Output:Languages which starts with J :JavaLanguages which ends with aJavaScalaPrint all languages :JavaScalaC++HaskellLispPrint no language :Print language whose length greater than 4:ScalaHaskell |
處理數(shù)據(jù)？用管道的方式更加簡潔
Java 8里面新增的Stream API ，讓集合中的數(shù)據(jù)處理起來更加方便，性能更高，可讀性更好
假設(shè)一個業(yè)務(wù)場景：對于20元以上的商品，進(jìn)行9折處理，最后得到這些商品的折后價(jià)格。
|
1
2
3
4
5
|
final BigDecimal totalOfDiscountedPrices = prices.stream().filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0).map(price -> price.multiply(BigDecimal.valueOf(0.9))).reduce(BigDecimal.ZERO,BigDecimal::add);System.out.println("Total of discounted prices: " + totalOfDiscountedPrices); |
想象一下：如果用面向?qū)ο筇幚磉@些數(shù)據(jù)，需要多少行？多少次循環(huán)？需要聲明多少個中間變量？
Lambda的陰暗面
前面都是講Lambda如何改變Java程序員的思維習(xí)慣，但Lambda確實(shí)也帶來了困惑
JVM可以執(zhí)行任何語言編寫的代碼，只要它們能編譯成字節(jié)碼，字節(jié)碼自身是充分OO的，被設(shè)計(jì)成接近于Java語言，這意味著Java被編譯成的字節(jié)碼非常容易被重新組裝。
但是如果不是Java語言，差距將越來越大，Scala源碼和被編譯成的字節(jié)碼之間巨大差距是一個證明，編譯器加入了大量合成類 方法和變量，以便讓JVM按照語言自身特定語法和流程控制執(zhí)行。
我們首先看看Java 6/7中的一個傳統(tǒng)方法案例：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
// simple check against empty stringspublic static int check(String s) { if (s.equals("")) { throw new IllegalArgumentException(); } return s.length();}//map names to lengthsList lengths = new ArrayList();for (String name : Arrays.asList(args)) { lengths.add(check(name));} |
如果一個空的字符串傳入，這段代碼將拋出錯誤，堆棧跟蹤如下：
|
1
2
|
at LmbdaMain.check(LmbdaMain.java:19)at LmbdaMain.main(LmbdaMain.java:34) |
再看看Lambda的例子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
Stream lengths = names.stream().map(name -> check(name)); at LmbdaMain.check(LmbdaMain.java:19)at LmbdaMain.lambda$0(LmbdaMain.java:37)at LmbdaMain$$Lambda$1/821270929.apply(Unknown Source)at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:512)at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:502)at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)at java.util.stream.LongPipeline.reduce(LongPipeline.java:438)at java.util.stream.LongPipeline.sum(LongPipeline.java:396)at java.util.stream.ReferencePipeline.count(ReferencePipeline.java:526)at LmbdaMain.main(LmbdaMain.java:39) |
這非常類似Scala，出錯棧信息太長，我們?yōu)榇a的精簡付出力代價(jià)，更精確的代碼意味著更復(fù)雜的調(diào)試。
但這并不影響我們喜歡Lambda！
總結(jié)
在Java世界里面，面向?qū)ο筮€是主流思想，對于習(xí)慣了面向?qū)ο缶幊痰拈_發(fā)者來說，抽象的概念并不陌生。面向?qū)ο缶幊淌菍?shù)據(jù)進(jìn)行抽象，而函數(shù)式編程是對行為進(jìn)行抽象。現(xiàn)實(shí)世界中，數(shù)據(jù)和行為并存，程序也是如此，因此這兩種編程方式我們都得學(xué)。
這種新的抽象方式還有其他好處。很多人不總是在編寫性能優(yōu)先的代碼，對于這些人來說，函數(shù)式編程帶來的好處尤為明顯。程序員能編寫出更容易閱讀的代碼——這種代碼更多地表達(dá)了業(yè)務(wù)邏輯，而不是從機(jī)制上如何實(shí)現(xiàn)。易讀的代碼也易于維護(hù)、更可靠、更不容易出錯。
在寫回調(diào)函數(shù)和事件處理器時，程序員不必再糾纏于匿名內(nèi)部類的冗繁和可讀性，函數(shù)式編程讓事件處理系統(tǒng)變得更加簡單。能將函數(shù)方便地傳遞也讓編寫惰性代碼變得容易，只有在真正需要的時候，才初始化變量的值。
總而言之，Java更趨于完美了。
