JDK8已經發布快4年的時間了，現在來談它的新特性顯得略微的有點“不合時宜”。盡管JDK8已不再“新”，但它的重要特性之一——Lambda表達式依然是不被大部分開發者所熟練運用，甚至不被開發者所熟知。

　　國內的開發環境大家都知道，有各種的老項目，有各種各樣的發布風險，讓公司以及項目組對新的技術往往望而卻步，有公司甚至時至今日還在使用JDK6來進行項目開發，這導致了在很多技術的選擇上受到了很大限制，進而不能跟隨時代的腳步使得項目甚至公司一步一步走向衰落。

　　本文簡單認識JDK8的重要新特性之一——Lambda表達式。 在JDK8之前，Java是不支持函數式編程的，所謂的函數編程，即可理解是將一個函數（也稱為“行為”）作為一個參數進行傳遞。通常我們提及得更多的是面向對象編程，面向對象編程是對數據的抽象（各種各樣的POJO類），而函數式編程則是對行為的抽象（將行為作為一個參數進行傳遞）。在JavaScript中這是很常見的一個語法特性，但在Java中將一個函數作為參數傳遞這卻行不通，好在JDK8的出現打破了Java的這一限制。

認識Lambda表達式

　　首先來引入一個示例，不知給是否有在IDEA編寫代碼的經歷，如果在JDK8的環境下如下所示按照Java傳統的語法規則編寫一個線程。

1 new Thread(new Runnable() {
2     @Override
3     public void run() {
4         System.out.println("Hello World!");
5     }
6 });

　　IDEA會給出提示可以使用Lambda表達式替換。

　　使用Lambda表達式則只需要使用一句話就可代替上面使用匿名類的方式。

new
 
 Thread(() -> System.out.println("Hello World!"));

　　在這個例子中，傳統的語法規則，我們是將一個匿名內部類作為參數進行傳遞，我們實現了Runnable接口，並將其作為參數傳遞給Thread類，這實際上我們傳遞的是一段代碼，也即我們將代碼作為了數據進行傳遞，這就帶來許多不必要的“樣板代碼”。

　　Lambda表達式一共有三部分組成：

　　後面的示例中我們會詳解這個結構，包括有無參數，有無返回值的問題。 那麽這個看起來奇奇怪怪的不太像Java的語法規則，其本身含義到底什麽呢？這也是開始困擾我的問題，什麽時候在什麽場景下可以使用Lambda表達式。

　　能夠接收Lambda表達式的參數類型，是一個只包含一個方法的接口。只包含一個方法的接口稱之為“函數接口”。

　　例如上面創建一個線程的示例，Runnable接口只包含一個方法，所以它被稱為“函數接口”，所以它可以使用Lambad表達式來代替匿名內部類。根據這個規則，我們試著來寫一個函數接口，並使用Lambda表達式作為參數傳遞。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函數接口：只有一個方法的接口。作為Lambda表達式的類型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface {
8     void test();
9 }

　　測試：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函數接口測試
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         func(new FunctionInterface() {
14             @Override
15             public void test() {
16                 System.out.println("Hello World!");
17             }
18         });
19         //使用Lambda表達式代替上面的匿名內部類
20         func(() -> System.out.println("Hello World"));
21     }
22 
23     private void func(FunctionInterface functionInterface) {
24         functionInterface.test();
25     }
26 }

　　可以看到，只要是一個接口中只包含一個方法，則可以使用Lambda表達式，這樣的接口稱之為“函數接口”。

　　上面的函數接口比較簡單不包含參數，也不包含返回值。

　　我們再來修改FunctionInterface函數接口逐步加大Lambda表達式的難度——包含參數，不包含返回值。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函數接口：只有一個方法的接口。作為Lambda表達式的類型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface {
8     void test(int param);
9 }

　　測試：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函數接口測試
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表達式代替匿名內部類
14         func((x) -> System.out.println("Hello World" + x));
15     }
16 
17     private void func(FunctionInterface functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

　　關註Lambda表達式“(x) -> Sysout.out.println("Hello World" + x)”，左邊傳遞的是參數，此處並沒有指明參數類型，因為它可以通過上下文進行類型推導，但在有些情況下不能推導出參數類型（在編譯時不能推導通常IDE會提示），此時則需要指明參數類型。我個人建議，任何情況下指明函數的參數類型。

　　哪種情況不能推導出參數類型呢？就是函數接口是一個泛型的時候。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函數接口：只有一個方法的接口。作為Lambda表達式的類型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface<T> {
8     void test(T param);
9 }　

　　測試：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函數接口測試
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表達式代替匿名內部類
14         func((Integer x) -> System.out.println("Hello World" + x));
15     }
16 
17     private void func(FunctionInterface<Integer> functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

　　上面的示例提到了Lambda表達式的兩種情況：

　　無參數，無返回值；

　　有參數，無返回值。

　　接下來就是有參數，有返回值這種較為復雜的情況。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函數接口：只有一個方法的接口。作為Lambda表達式的類型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface<T> {
8     boolean test(T param);
9 }

　　測試：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函數接口測試
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表達式代替匿名內部類
14         func((Integer x) -> true);
15     }
16 
17     private void func(FunctionInterface<Integer> functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

　　此時的Lambda表達式“(Integer x) -> true”，右邊是表達式的主體，直接返回true，如果有多行代碼，則可以直接使用花括號表示，例如：

func((Integer x) -> {
    System.out.println("Hello World" + x);
    return true;
});

　　Lambda表達式基本的語法規則：

　　無參數，無返回值；

　　有參數，無返回值；

　　有參數，有返回值。

　　這三種基本情況已經大致清楚了，特別是需要弄清，什麽時候可以使用Lambda表達式代替匿名內部類，也就是Lambda表達式的應用場景是函數接口。Lambda表達式這一新特性在JDK8中的引入，更大的好處則是集合API的更新，新增的Stream類庫，使得我們在遍歷使用集合時不再像以往那樣不斷地使用for循環。

JDK8使用集合的正確姿勢

　　示例：計算來自“chengdu”的學生數量有多少。

　　在JDK8前的代碼：

for (Student student : studentList) {
    if (student.getCity().equals("chengdu")) {
        count++;
    }
}

　　JDK8使用集合的正確姿勢：

count = studentList.stream().filter((student -> student.getCity().equals("chengdu"))).count();

　　API的使用“難度”恰似提高了，實際只是不熟悉而已。傳統叠代的方式需要閱讀完整個循環才能明白代碼邏輯，JDK8通過流的方式則可以望文生義且代碼量大大減小。

　　其中最為重要的是——Stream流。Stream的是通過函數式編程方式實現的在集合類上進行復雜操作的工具。若要詳細講解Stream的實現方式我相信再寫一篇博客也不為過，所以此處不再考查Stream的內部實現。這裏是想告訴大家，如果有幸使用JDK8的開發環境進行開發，盡量學習使用新的集合操作API。

　　上面對於Lambda表達式以及函數式編程僅僅只是到了一個“認識”的地步，似乎只是感受到了縮小代碼量，本文對於Lambda式的認識不深入更多的是對於後面更多的知識做一個鋪墊或者作為一個掃盲貼，有關Lambda表達式的應用太多，並發編程、響應式編程等等。如果你有關於Lambda表達式或者函數式編程有更好的見解不妨留下評論。

這是一個能給程序員加buff的公眾號

JDK8的新特性——Lambda表達式