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 }
1 @FunctionalInterface 2 public interface Callable<V> { 3 V call() throws Exception; 4 }
以下接口中雖然有兩個方法，但因hashCode()是Object類中的方法，因此該接口也是函數式接口：
1 @FunctionalInterface 2 public interfaceFuncInterface { 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個部分：
- 左邊的參數列表，對應的是函數式接口中抽象方法的參數列表；
- 中間的符號:->,為固定寫法;
- 右邊大括號內對函數接口抽象方法的實現。
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表達式