下面對幾個常用的特性做下重點說明。
<h1>一、Lambda表達(dá)式<h1>
<h2>1.1 函數(shù)式編程</h2>
百科介紹：http://baike.baidu.com/link?url=LL9X3-SoS4XJGgdzrXvURuKEGm6ad5zY1NLDxDygjTaSRnEZ0Bp3wqX0QgkB7fjPwMSQS1tLfqdRMKUhNti7MH7DEK7JQ_lXcs9k6LXHT1A9dSJW8uwJMONJcvXY53h6myMCkqjL3IqW8QRgbdNDl_
函數(shù)編程非常關(guān)鍵的幾個特性如下：
（1）閉包與高階函數(shù)
函數(shù)編程支持函數(shù)作為第一類對象，有時稱為 閉包或者 仿函數(shù)（functor）對象。實質(zhì)上，閉包是起函數(shù)的作用并可以像對象一樣操作的對象。
與此類似，F(xiàn)P 語言支持 高階函數(shù)。高階函數(shù)可以用另一個函數(shù)（間接地，用一個表達(dá)式） 作為其輸入?yún)?shù)，在某些情況下，它甚至返回一個函數(shù)作為其輸出參數(shù)。這兩種結(jié)構(gòu)結(jié)合在一起使得可以用優(yōu)雅的方式進(jìn)行模塊化編程，這是使用 FP 的最大好處。
（2）惰性計算
在惰性計算中，表達(dá)式不是在綁定到變量時立即計算，而是在求值程序需要產(chǎn)生表達(dá)式的值時進(jìn)行計算。延遲的計算使您可以編寫可能潛在地生成無窮輸出的函數(shù)。因為不會計算多于程序的其余部分所需要的值，所以不需要擔(dān)心由無窮計算所導(dǎo)致的 out-of-memory 錯誤。
（3）沒有“副作用”
所謂"副作用"（side effect），指的是函數(shù)內(nèi)部與外部互動（最典型的情況，就是修改全局變量的值），產(chǎn)生運算以外的其他結(jié)果。函數(shù)式編程強調(diào)沒有"副作用"，意味著函數(shù)要保持獨立，所有功能就是返回一個新的值，沒有其他行為，尤其是不得修改外部變量的值。
綜上所述，函數(shù)式編程可以簡言之是： 使用不可變值和函數(shù)， 函數(shù)對一個值進(jìn)行處理， 映射成另一個值。這個值在面向?qū)ο笳Z言中可以理解為對象，另外這個值還可以作為函數(shù)的輸入。
<h2>1.2 Lambda表達(dá)式</h2>
官方教程地址
<h3>1.2.1 語法</h3>
完整的Lambda表達(dá)式由三部分組成：參數(shù)列表、箭頭、聲明語句；
<pre><code>(Type1 param1, Type2 param2, ..., TypeN paramN) -> { statment1; statment2; //............. return statmentM;
}</pre></code>
- 絕大多數(shù)情況，編譯器都可以從上下文環(huán)境中推斷出lambda表達(dá)式的參數(shù)類型，所以參數(shù)可以省略：
<pre><code>(param1,param2, ..., paramN) -> { statment1; statment2; //............. return statmentM;
}</pre></code>
2、 當(dāng)lambda表達(dá)式的參數(shù)個數(shù)只有一個，可以省略小括號：
<pre><code>param1 -> { statment1; statment2; //............. return statmentM;
}</pre></code>
3、 當(dāng)lambda表達(dá)式只包含一條語句時，可以省略大括號、return和語句結(jié)尾的分號：
<pre><code>param1 -> statment</pre></code>
這個時候JVM會自動計算表達(dá)式值并返回，另外這種形式還有一種更簡寫法，方法引用寫法，具體可以看下面的方法引用的部分。
<h3>1.2.2 函數(shù)接口</h3>函數(shù)接口是只有一個抽象方法的接口， 用作 Lambda 表達(dá)式的返回類型。
接口包路徑為java.lang.function，然后接口類上面都有@FunctionalInterface這個注解。下面列舉幾個較常見的接口類。
這些函數(shù)接口在使用Lambda表達(dá)式時做為返回類型，JDK定義了很多現(xiàn)在的函數(shù)接口，實際自己也可以定義接口去做為表達(dá)式的返回，只是大多數(shù)情況下JDK定義的直接拿來就可以用了。而且這些接口在JDK8集合類使用流操作時大量被使用。
<h3>1.2.3 類型檢查、類型推斷</h3>
Java編譯器根據(jù) Lambda 表達(dá)式上下文信息就能推斷出參數(shù)的正確類型。 程序依然要經(jīng)過類型檢查來保證運行的安全性， 但不用再顯式聲明類型罷了。 這就是所謂的類型推斷。Lambda 表達(dá)式中的類型推斷， 實際上是 Java 7 就引入的目標(biāo)類型推斷的擴展。
有時候顯式寫出類型更易讀，有時候去掉它們更易讀。沒有什么法則說哪種更好；對于如何讓代碼更易讀，程序員必須做出自己的選擇。
<h3>1.2.4 局部變量限制</h3>
Lambda表達(dá)式也允許使用自由變量（不是參數(shù)，而是在外層作用域中定義的變量），就像匿名類一樣。 它們被稱作捕獲Lambda。 Lambda可以沒有限制地捕獲（也就是在其主體中引用）實例變量和靜態(tài)變量。但局部變量必須顯式聲明為final，或事實上是final。
為什么局部變量有這些限制？
（1）實例變量和局部變量背后的實現(xiàn)有一個關(guān)鍵不同。實例變量都存儲在堆中，而局部變量則保存在棧上。如果Lambda可以直接訪問局部變量，而且Lambda是在一個線程中使用的，則使用Lambda的線程，可能會在分配該變量的線程將這個變量收回之后，去訪問該變量。因此， Java在訪問自由局部變量時，實際上是在訪問它的副本，而不是訪問原始變量。如果局部變量僅僅賦值一次那就沒有什么區(qū)別了——因此就有了這個限制。
（2）這一限制不鼓勵你使用改變外部變量的典型命令式編程模式。
<h3>1.2.5 使用示例</h3>
<pre>
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
long num = list.stream().filter( a -> a > 4 ).count();
System.out.println(num);
</pre>
上面這段是統(tǒng)計list中大于4的值的個數(shù)，使用的lambda表達(dá)式為a-> a> 4，這里參數(shù)a沒有定義類型，會自動判斷為Integer類型，而這個表達(dá)式的值會自動轉(zhuǎn)化成函數(shù)接口Predicate對應(yīng)的對象（filter方法定義的輸入?yún)?shù)類型），至于stream及相關(guān)的操作則是下面要說的流操作。它們經(jīng)常一起配合進(jìn)行一起數(shù)據(jù)處理。
<h1>二、流</h1>
<h2>2.1 流介紹</h2>
流是Java API的新成員，它允許你以聲明性方式處理數(shù)據(jù)集合（通過查詢語句來表達(dá)，而不是臨時編寫一個實現(xiàn)）。就現(xiàn)在來說，你可以把它們看成遍歷數(shù)據(jù)集的高級迭代器。此外，流還可以透明地并行處理，你無需寫任何多線程代碼了！
<h2>2.2 使用流</h2>
| 類別 | 方法名 | 方法簽名 | 作用 |
|---|---|---|---|
| 篩選切片 | filter | Stream<T> filter(Predicate<? super T> predicate) | 過濾操作，根據(jù)Predicate判斷結(jié)果保留為真的數(shù)據(jù)，返回結(jié)果仍然是流 |
| distinct | Stream<T> distinct() | 去重操作，篩選出不重復(fù)的結(jié)果，返回結(jié)果仍然是流 | |
| limit | Stream<T> limit(long maxSize) | 截取限制操作，只取前 maxSize條數(shù)據(jù)，返回結(jié)果仍然是流 | |
| skip | Stream<T> skip(long n) | 跳過操作，跳過n條數(shù)據(jù)，取后面的數(shù)據(jù)，返回結(jié)果仍然是流 | |
| 映射 | map | <R> Stream<R> map(Function<? super T, ? extends R> mapper) | 轉(zhuǎn)化操作，根據(jù)參數(shù)T，轉(zhuǎn)化成R類型，返回結(jié)果仍然是流 |
| flatMap | <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) | 轉(zhuǎn)化操作，根據(jù)參數(shù)T，轉(zhuǎn)化成R類型流，這里會生成多個R類型流，返回結(jié)果仍然是流 | |
| 匹配 | anyMatch | boolean anyMatch(Predicate<? super T> predicate) | 判斷是否有一條匹配，根據(jù)Predicate判斷結(jié)果中是否有一條匹配成功 |
| allMatch | boolean allMatch(Predicate<? super T> predicate) | 判斷是否全都匹配，根據(jù)Predicate判斷結(jié)果中是否全部匹配成功 | |
| noneMatch | boolean noneMatch(Predicate<? super T> predicate) | 判斷是否一條都不匹配，根據(jù)Predicate判斷結(jié)果中是否所有的都不匹配 | |
| 查找 | findAny | Optional<T> findAny() | 查找操作， 查詢當(dāng)前流中的任意元素并返回Optional |
| findFirst | Optional<T> findFirst() | 查找操作， 查詢當(dāng)前流中的第一個元素并返回Optional | |
| 歸約 | reduce | T reduce(T identity, BinaryOperator<T> accumulator); | 歸約操作，同樣兩個類型的數(shù)據(jù)進(jìn)行操作后返回相同類型的結(jié)果。比如兩個整數(shù)相加、相乘等。 |
| max | Optional<T> max(Comparator<? super T> comparator) | 求最大值，根據(jù)Comparator計算的比較結(jié)果得到最大值 | |
| min | Optional<T> min(Comparator<? super T> comparator) | 求最小值，根據(jù)Comparator計算的比較結(jié)果得到最小值 | |
| 匯總統(tǒng)計 | collect | <R, A> R collect(Collector<? super T, A, R> collector) | 匯總操作，匯總對應(yīng)的處理結(jié)果。這里經(jīng)常與 |
| count | long count() | 統(tǒng)計流中數(shù)據(jù)數(shù)量 | |
| 遍歷 | foreach | void forEach(Consumer<? super T> action) | 遍歷操作，遍歷執(zhí)行Consumer 對應(yīng)的操作 |
上面是Stream API的一些常用操作，按場景結(jié)合lambda表達(dá)式調(diào)用對應(yīng)方法即可。至于Stream的生成方式，Stream的of方法或者Collection接口實現(xiàn)類的stream方法都可以獲得對應(yīng)的流對象，再進(jìn)一步根據(jù)需要做對應(yīng)處理。
另外上述方法如果返回是Stream對象時是可以鏈?zhǔn)秸{(diào)用的，這個時候這個操作只是聲明或者配方，不產(chǎn)生新的集合，這種類型的方法是惰性求值方法；有些方法返回結(jié)果非Stream類型，則是及早求值方法。
“為什么要區(qū)分惰性求值和及早求值？ 只有在對需要什么樣的結(jié)果和操 作有了更多了解之后， 才能更有效率地進(jìn)行計算。 例如， 如果要找出大于 10 的第一個數(shù)字， 那么并不需要和所有元素去做比較， 只要找出第一個匹配的元素就夠了。 這也意味著可以在集合類上級聯(lián)多種操作， 但迭代只需一次。這也是函數(shù)編程中惰性計算的特性，即只在需要產(chǎn)生表達(dá)式的值時進(jìn)行計算。這樣代碼更加清晰，而且省掉了多余的操作。
這里還對上述列表操作中相關(guān)的Optional與Collectors類做下說明。
Optional類是為了解決經(jīng)常遇到的NullPointerException出現(xiàn)的，這個類是一個可能包含空值的容器類。用Optional替代null可以顯示說明結(jié)果可能為空或不為空，再使用時使用isPresent方法判斷就可以避免直接調(diào)用的空指針異常。
Collectors類是一個非常有用的是歸約操作工具類，工具類中的方法常與流的collect方法結(jié)合使用。比如
groupingBy方法可以用來分組，在轉(zhuǎn)化Map時非常實用；partitioningBy方法可以用來分區(qū)（分區(qū)可以當(dāng)做一種特殊的分組，真假值分組），joining方法可以用來連接，這個應(yīng)用在比如字符串拼接的場景。
<h2>2.3 并行流</h2>
Collection接口的實現(xiàn)類調(diào)用parallelStream方法就可以實現(xiàn)并行流，相應(yīng)地也獲得了并行計算的能力。或者Stream接口的實現(xiàn)調(diào)用parallel方法也可以得到并行流。并行流實現(xiàn)機制是基于fork/join 框架，將問題分解再合并處理。
不過并行計算是否一定比串行快呢？這也不一定。實際影響性能的點包括：
（1）數(shù)據(jù)大小輸入數(shù)據(jù)的大小會影響并行化處理對性能的提升。 將問題分解之后并行化處理， 再將結(jié)果合并會帶來額外的開銷。 因此只有數(shù)據(jù)足夠大、 每個數(shù)據(jù)處理管道花費的時間足夠多
時， 并行化處理才有意義。
（2） 源數(shù)據(jù)結(jié)構(gòu)
每個管道的操作都基于一些初始數(shù)據(jù)源， 通常是集合。 將不同的數(shù)據(jù)源分割相對容易，這里的開銷影響了在管道中并行處理數(shù)據(jù)時到底能帶來多少性能上的提升。
（3） 裝箱
處理基本類型比處理裝箱類型要快。
（4） 核的數(shù)量
極端情況下， 只有一個核， 因此完全沒必要并行化。 顯然， 擁有的核越多， 獲得潛在性能提升的幅度就越大。 在實踐中， 核的數(shù)量不單指你的機器上有多少核， 更是指運行時你的機器能使用多少核。 這也就是說同時運行的其他進(jìn)程， 或者線程關(guān)聯(lián)性（ 強制線程在某些核或 CPU 上運行） 會影響性能。
（5） 單元處理開銷
比如數(shù)據(jù)大小， 這是一場并行執(zhí)行花費時間和分解合并操作開銷之間的戰(zhàn)爭。 花在流中
每個元素身上的時間越長， 并行操作帶來的性能提升越明顯
實際在考慮是否使用并行時需要考慮上面的要素。在討論流中單獨操作每一塊的種類時， 可以分成兩種不同的操作： 無狀態(tài)的和有狀態(tài)的。無狀態(tài)操作整個過程中不必維護狀態(tài)， 有狀態(tài)操作則有維護狀態(tài)所需的開銷和限制。如果能避開有狀態(tài)， 選用無狀態(tài)操作， 就能獲得更好的并行性能。 無狀態(tài)操作包括 map、filter 和 flatMap， 有狀態(tài)操作包括 sorted、 distinct 和 limit。這種理解在理論上是更好的，當(dāng)然實際使用還是以測試結(jié)果最為可靠 。
<h1>三、方法引用</h1>
方法引用的基本思想是，如果一個Lambda代表的只是“直接調(diào)用這個方法”，那最好還是用名稱來調(diào)用它，而不是去描述如何調(diào)用它。事實上，方法引用就是讓你根據(jù)已有的方法實現(xiàn)來創(chuàng)建Lambda表達(dá)式。但是，顯式地指明方法的名稱，你的代碼的可讀性會更好。所以方法引用只是在內(nèi)容中只有一個表達(dá)式的簡寫。
當(dāng) 你 需 要使用 方 法 引用時 ， 目 標(biāo)引用 放 在 分隔符::前 ，方法 的 名 稱放在 后 面 ，即ClassName :: methodName 。例如 ，Apple::getWeight就是引用了Apple類中定義的方法getWeight。請記住，不需要括號，因為你沒有實際調(diào)用這個方法。方法引用就是Lambda表達(dá)式(Apple a) -> a.getWeight()的快捷寫法。
這里有種情況需要特殊說明，就是類的構(gòu)造函數(shù)情況，這個時候是通過ClassName::new這種形式創(chuàng)建Class構(gòu)造函數(shù)對應(yīng)的引用，例如：
<h1>四、默認(rèn)方法</h1>
<h2>4.1 介紹</h2>
為了以兼容方式改進(jìn)API，Java 8中加入了默認(rèn)方法。主要是為了支持庫設(shè)計師，讓他們能夠?qū)懗龈菀赘倪M(jìn)的接口。具體寫法是在接口中加default關(guān)鍵字修飾。
<h2>4.2 使用說明</h2>
默認(rèn)方法由于是為了避免兼容方式改進(jìn)API才引入，所以一般正常開發(fā)中不會使用，除非你也想改進(jìn)API，而不影響老的接口實現(xiàn)。當(dāng)然在JDK8有大量的地方用到了默認(rèn)方法，所以對這種寫法有一定的了解還是有幫助的。
采用默認(rèn)方法之后，你可以為這個方法提供一個默認(rèn)的實現(xiàn)，這樣實體類就無需在自己的實現(xiàn)中顯式地提供一個空方法，而是默認(rèn)就有了實現(xiàn)。
<h2>4.3 注意事項</h2>
由于類可以實現(xiàn)多個接口，也可以繼承類，當(dāng)接口或類中有相同函數(shù)簽名的方法時，這個時候到底使用哪個類或接口的實現(xiàn)呢？
這里有三個規(guī)則可以進(jìn)行判斷：
(1) 類中的方法優(yōu)先級最高。類或父類中聲明的方法的優(yōu)先級高于任何聲明為默認(rèn)方法的優(yōu)先級。
(2) 如果無法依據(jù)第一條進(jìn)行判斷，那么子接口的優(yōu)先級更高：函數(shù)簽名相同時，優(yōu)先選擇擁有最具體實現(xiàn)的默認(rèn)方法的接口，即如果B繼承了A，那么B就比A更加具體。
(3) 最后，如果還是無法判斷，繼承了多個接口的類必須通過顯式覆蓋和調(diào)用期望的方法，顯式地選擇使用哪一個默認(rèn)方法的實現(xiàn)。不然編譯都會報錯。
<h1>五、方法參數(shù)反射</h1>
JDK8 新增了Method.getParameters方法，可以獲取參數(shù)信息，包括參數(shù)名稱。不過為了避免.class文件因為保留參數(shù)名而導(dǎo)致.class文件過大或者占用更多的內(nèi)存，另外也避免有些參數(shù)（ secret/password）泄露安全信息，JVM默認(rèn)編譯出的class文件是不會保留參數(shù)名這個信息的。
這一選項需由編譯開關(guān)javac -parameters打開，默認(rèn)是關(guān)閉的。在Eclipse（或者基于Eclipse的IDE）中可以如下圖勾選保存：
<h1>六、日期/時間改進(jìn)</h1>
1.8之前JDK自帶的日期處理類非常不方便，我們處理的時候經(jīng)常是使用的第三方工具包，比如commons-lang包等。不過1.8出現(xiàn)之后這個改觀了很多，比如日期時間的創(chuàng)建、比較、調(diào)整、格式化、時間間隔等。
這些類都在java.time包下。比原來實用了很多。
<h2>6.1 LocalDate/LocalTime/LocalDateTime</h2>
LocalDate為日期處理類、LocalTime為時間處理類、LocalDateTime為日期時間處理類，方法都類似，具體可以看API文檔或源碼，選取幾個代表性的方法做下介紹。
now相關(guān)的方法可以獲取當(dāng)前日期或時間，of方法可以創(chuàng)建對應(yīng)的日期或時間，parse方法可以解析日期或時間，get方法可以獲取日期或時間信息，with方法可以設(shè)置日期或時間信息，plus或minus方法可以增減日期或時間信息；
<h2>6.2 TemporalAdjusters</h2>
這個類在日期調(diào)整時非常有用，比如得到當(dāng)月的第一天、最后一天，當(dāng)年的第一天、最后一天，下一周或前一周的某天等。
<h2>6.3 DateTimeFormatter</h2>
以前日期格式化一般用SimpleDateFormat類，但是不怎么好用，現(xiàn)在1.8引入了DateTimeFormatter類，默認(rèn)定義了很多常量格式（ISO打頭的），在使用的時候一般配合LocalDate/LocalTime/LocalDateTime使用，比如想把當(dāng)前日期格式化成yyyy-MM-dd hh:mm:ss的形式:
<pre><code>LocalDateTime dt = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
System.out.println(dtf.format(dt));</pre></code>
<h1>七、參考資料</h1>
官方教程：http://docs.oracle.com/javase/tutorial/
《Java 8實戰(zhàn)》
《Java 8函數(shù)式編程》
