Java8新特性之一：Lambda表達式

Java8新特性之一：Lambda表達式

Java8是自java5之後最重大的一次更新，它給JAVA語言帶來了很多新的特性（包括編譯器、類庫、工具類、JVM等），其中最重要的更新是它給我們帶來了Lambda表達式和Stream API。

1、什麼是Lambda表達式？

　　Lambda是一個匿名函數，可以了解為是一段可以傳遞的代碼，可以将代碼像傳遞參數、傳遞資料一樣進行傳輸。使用Lambda表達式，可以寫出更加緊湊、更加簡潔、更加靈活的代碼。

2、使用Lambda的限制條件

　　Lambda并不是任何地方都可以使用，Lambda表達式需要“函數式接口”的支援。

3、什麼是函數式接口？

　　接口中隻有一個抽象方法的接口，稱為函數式接口，可以用@FunctionalInterface修飾一下，這裡需要注意的是：未使用 @FunctionalInterfaces注解的接口未必就不是函數式接口，一個接口是不是函數式接口的條件隻有一條，即接口中隻有一個抽象方法的接口（Object類中的方法不算）。而使用@FunctionalInterface注解修飾了的接口就一定是函數式接口，添加@FunctionalInterface注解可以幫助我們檢查是否是函數式接口。

JDK中常見的函數式接口有：

1 @FunctionalInterface

2 public interface Runnable {

3 void run();

4 }

2 public interface Callable {

3 V call() throws Exception;

以下接口中雖然有兩個方法，但因hashCode()是Object類中的方法，是以該接口也是函數式接口：

複制代碼

2 public interface FuncInterface {

3

4 void doSomething();

5

6 int hashCode(); // Object類中的方法

7 }

4、Lambda表達式示例

　　需求一：開啟一個線程，線上程中列印出"Hello World"

　　未使用Lambda表達式時的寫法：

1 public class LambdaTest {

2

3 public void print() {

4

5 Thread thread = new Thread(new Runnable() {

6 @Override

7 public void run() {

8 System.out.println("Hello World");

9 }

10 });

11

12 thread.start();

13 }14 }

　　使用Lambda時的寫法：

1 public class LambdaTest {

3 public void print() {

4 Thread thread = new Thread(() -> System.out.println("Hello World"));

5 }

6 }

　　需求二：模拟一個電腦，使其可以進行簡單的加、減、乘操作

　　（1）、電腦操作函數式接口

2 public interface Calculator {

3 T operation(T t1,T t2);

　　（2）具體操作

1 public class CalculatorTest {

3 public Integer operator(Integer v1,Integer v2,Calculator calculator) {

4 return calculator.operation(v1,v2);

5 }

6

7 public Integer add(Integer v1,Integer v2) {

8 return operator(v1,v2,(x,y) -> x + y);

9 }

10

11 public Integer subtr(Integer v1,Integer v2) {

12 return operator(v1,v2,(x,y) -> x - y);

13 }

14

15 public Integer multi(Integer v1,Integer v2) {

16 return operator(v1,v2,(x,y) -> x * y);

17 }

18

19 public static void main(String[] args) {

20

21 CalculatorTest calculatorTest = new CalculatorTest();

22

23 // 加法

24 Integer add = calculatorTest.add(1,2);

25

26 // 減法

27 Integer sub = calculatorTest.subtr(100,82);

28

29 // 乘法

30 Integer multi = calculatorTest.multi(5,3);

31

32 System.out.println(add);

33 System.out.println(sub);

34 System.out.println(multi);

35 }

36 }

　　運作結果：

15

　　從需求一中，我們可以看出，使用Lambda比使用匿名内部類代碼更加簡潔，同時，也可以了解為什麼Lambda必須需要函數式接口的支援。我們假設Runnable中有兩個方法，那麼，“() -> System.out.println(Thread.currentThread().getName())”應該去找哪個方法去實作？

　　從需求二的例子中，我們可以更加了解“一段可以傳遞的代碼”這句話的含義。對資料的操作方法定義在Calculator接口中，而加、減、乘的具體實作代碼在各自的方法中，并将這些實作作為參數傳遞給CalculatorTest類的operator()方法，最終傳回操作結果。

5、Lambda表達式的文法

5.1 Lambda表達式的文法結構

(參數清單，對應的是接口中對應的抽象方法的參數清單) -> {對抽象方法的實作}

　　Lambda表達式文法分在3個部分：

左邊的參數清單，對應的是函數式接口中抽象方法的參數清單；

中間的符号:->,為固定寫法;

右邊大括号内對函數接口抽象方法的實作。

　　Lambda表達式的在具體場景下可以有簡略寫法。

5.2 文法格式一：無參數，無傳回值

1 Runnable runnable = () -> {System.out.println("Hello World");}

2 Runnable runnable = () -> System.out.println("Hello World"); // 簡寫形式

　　此時，如果右邊的代碼簡單，隻有一行代碼時，{}可以省略。

5.2 文法格式二：有一個參數，無傳回值

3 public void print(Consumer msg) {

4 System.out.println(msg);

7 public void doPrint(String msg) {

8 print((str) -> System.out.println(msg));

9 print(str -> System.out.println(msg)); // 簡寫

11 }

12 }

　　此時，左邊的()可以省略。

5.3 文法格式三：Lambda體内隻有一條語句，且有傳回值，return可省略

1 public Integer subtr(Integer v1,Integer v2) {

2 return operator(v1,v2,(x,y) -> x - y);

3 }

5.4 文法格式四：有兩個以上參數，且Lambda體中有多條語句

1 public Integer add(Integer v1,Integer v2) {

2 return operator(v1,v2,(x,y) -> {

3 System.out.println("進行加法運算");

4 return x + y;

5 });

6 }

5.5 文法格式五：Lambda表達式的資料類型可以省略不寫

　　JVM編譯器通過上下文可以推斷出資料類型，但要注意的是，當多個參數時，要麼都寫，要麼都不寫，不能有的寫，有的不寫：

2 return operator(v1,v2,(Integer x,y) -> x - y); // 錯誤

3 }

5 public Integer subtr(Integer v1,Integer v2) {

6 return operator(v1,v2,(x,y) -> x - y); // 正确

7 }

6、Java8四大内置核心函數式接口

Consumer : 消費型接口（無傳回值，有去無回）

void accept(T t);           

Supplier : 供給型接口

T get();
                

Function : 函數型接口

R apply(T t);
               

Predicate : 斷言型接口

boolean test(T t);
               

四大核心接口的-->擴充子接口

　　示例：

1 import lombok.Getter;

2 import lombok.Setter;

4 import java.util.function.Consumer;

5 import java.util.function.Function;

6 import java.util.function.Predicate;

7 import java.util.function.Supplier;

8

9 @Getter

10 @Setter

11 class User {

12 private String username;

13 private int age;

15 @Override

16 public String toString() {

17 return "User{" +

18 "username='" + username + ''' +

19 ", age=" + age +

20 '}';

21 }

22 }

23

24 public class InnerInterface {

26 /**

27 * 列印user資訊

28 */

29 public void print(User user,Consumer userConsumer) {

30 userConsumer.accept(user);

31 }

32

33 /**

34 * 傳回一個user

35 */

36 public User getUser(Supplier userSupplier) {

37 return userSupplier.get();

38 }

39

40 /**

41 * 轉換一個user

42 */

43 public User transformUser(User user,Function function) {

44 return function.apply(user);

45 }

46

47 /**

48 * 檢驗User是否合法

49 */

50 public boolean checkUser(User user, Predicate predicate) {

51 return predicate.test(user);

52 }

53

54 public static void main(String[] args) {

55

56 User userObj = new User();

57 userObj.setUsername("西門吹雪");

58 userObj.setAge(22);

59

60 // 測試Consumer

61 InnerInterface mainInst = new InnerInterface();

62 mainInst.print(userObj,user -> System.out.println(user));

63

64 // 測試Supplier

65 final User user1 = mainInst.getUser(() -> {

66 User user = new User();

67 user.setUsername("葉孤城");

68 user.setAge(22);

69 return user;

70 });

71 System.out.println(user1);

72

73 // 将西門吹雪的年齡改為25

74 final User user2 = mainInst.transformUser(userObj, (user -> {

75 user.setAge(25);

76 return user;

77 }));

78 System.out.println(user2);

79

80 // 判斷User是否是西門吹雪

81 final boolean checkUser = mainInst.checkUser(userObj, (user -> user.getUsername().equals("西門吹雪")));

82 System.out.println(checkUser);

83 }

84 }

User{username='西門吹雪', age=22}

User{username='葉孤城', age=22}

User{username='西門吹雪', age=25}

true

　　以上四大核心内置接口是我們日常開發中經常要用到的，同時，它們還有一些變種，如：

　　BiConsumer，Consumer的增強版，接受兩個參數：

2 public interface BiConsumer {

4 void accept(T t, U u);

5 }

　　BiFunction類似，Function的增強版，接受兩個參數，傳回一個參數：

1 @FunctionalInterface

2 public interface BiFunction {

4 R apply(T t, U u);

6 default BiFunction andThen(Function<? super R, ? extends V> after) {

7 Objects.requireNonNull(after);

8 return (T t, U u) -> after.apply(apply(t, u));

10 }

　　其他的類似，這些函數式接口都在java.util.function包下，讀者可去這個包下去查詢。

原文位址

https://www.cnblogs.com/wuhenzhidu/p/lambda.html