1. 程式人生 > >Java8新特性之一:Lambda表達式

Java8新特性之一:Lambda表達式

interface 寫法 java hashcode code efault sta turn ring

  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 }
1 @FunctionalInterface
2 public interface Callable<V> {
3     V call() throws Exception;
4 }

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

1 @FunctionalInterface
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 {
2     
3     public void print() {
4         Thread thread = new Thread(() -> System.out.println("Hello World"));
5     }
6 }

  需求二:模擬一個計算器,使其可以進行簡單的加、減、乘操作

  (1)、計算器操作函數式接口

1 @FunctionalInterface
2 public interface Calculator<T> {
3     T operation(T t1,T t2);
4 }

  (2)具體操作

 1 public class CalculatorTest {
 2 
 3     public Integer operator(Integer v1,Integer v2,Calculator<Integer> 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 }

  運行結果:

3
18
15

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

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

5、Lambda表達式的語法

5.1 Lambda表達式的語法結構

(參數列表,對應的是接口中對應的抽象方法的參數列表) -> {對抽象方法的實現}

  Lambda表達式語法分在3個部分:

  1. 左邊的參數列表,對應的是函數式接口中抽象方法的參數列表;
  2. 中間的符號:->,為固定寫法;
  3. 右邊大括號內對函數接口抽象方法的實現。

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

5.2 語法格式一:無參數,無返回值

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

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

5.2 語法格式二:有一個參數,無返回值

 1 public class CalculatorTest {
 2 
 3     public void print(Consumer<String> msg) {
 4         System.out.println(msg);
 5     }
 6     
 7     public void doPrint(String msg) {
 8         print((str) -> System.out.println(msg));
 9         print(str -> System.out.println(msg));  // 簡寫
10 
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編譯器通過上下文可以推斷出數據類型,但要註意的是,當多個參數時,要麽都寫,要麽都不寫,不能有的寫,有的不寫:

1 public Integer subtr(Integer v1,Integer v2) {
2         return operator(v1,v2,(Integer x,y) -> x - y);   // 錯誤
3     }
4 
5 public Integer subtr(Integer v1,Integer v2) {
6         return operator(v1,v2,(x,y) -> x - y);    // 正確
7     }

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

 Consumer<T> : 消費型接口(無返回值,有去無回)
         void accept(T t);
 Supplier<T> : 供給型接口
         T get();
         
 Function<T,R> : 函數型接口
        R apply(T t);
        
 Predicate<T> : 斷言型接口
        boolean test(T t);
        
四大核心接口的-->擴展子接口

  示例:

 1 import lombok.Getter;
 2 import lombok.Setter;
 3 
 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;
14 
15     @Override
16     public String toString() {
17         return "User{" +
18                 "username=‘" + username + ‘\‘‘ +
19                 ", age=" + age +
20                 ‘}‘;
21     }
22 }
23 
24 public class InnerInterface {
25 
26     /**
27      * 打印user信息
28      */
29     public void print(User user,Consumer<User> userConsumer) {
30         userConsumer.accept(user);
31     }
32 
33     /**
34      * 返回一個user
35      */
36     public User getUser(Supplier<User> userSupplier) {
37         return userSupplier.get();
38     }
39 
40     /**
41      * 轉換一個user
42      */
43     public User transformUser(User user,Function<User,User> function) {
44         return function.apply(user);
45     }
46 
47     /**
48      * 檢驗User是否合法
49      */
50     public boolean checkUser(User user, Predicate<User> 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的增強版,接受兩個參數:

1 @FunctionalInterface
2 public interface BiConsumer<T, U> {
3 
4     void accept(T t, U u);
5 }

  BiFunction類似,Function的增強版,接受兩個參數,返回一個參數:

 1 @FunctionalInterface
 2 public interface BiFunction<T, U, R> {
 3 
 4     R apply(T t, U u);
 5     
 6     default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
 7         Objects.requireNonNull(after);
 8         return (T t, U u) -> after.apply(apply(t, u));
 9     }
10 }

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

Java8新特性之一:Lambda表達式