Lambda表達式-使用說明

　　　jdk8已經發布4年，其中有一個特性：Lambda，它是一個令開發者便捷開發的一種方式，Lambda Expression （Lambda表達式）是爲了讓java提供一種面向函數編程，本來在jdk8以前只支持面向對象編程，

而函數式編程則是對行爲的抽象（將行爲做爲一個參數進行傳遞），接下來經過例子來講明：

這是一個線程對象，傳入匿名內部類的例子：

new Thread(new Runnable() { @Override public void run() { System.out.println("Hello World!"); } });

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表達式的應用太多，併發編程、響應式編程等等。

 

本文引用：http://www.cnblogs.com/yulinfeng/p/8452379.html