必知必會之Lambda表示式
阿新 • • 發佈：2020-02-20
Java是一門強大的面向物件的語言，除了8種基本的資料型別，其他一切皆為物件。因此，在Java中定義函式或方法都離不開物件，也就意味著很難直接將方法或函式像引數一樣傳遞，而Java8中的Lambda表示式解決了這個問題。
一、為什麼需要Lambda？
簡單的來說，引入Lambda就是為了簡化程式碼，允許把函式作為一個方法的引數傳遞進方法中。
1.1 真的簡化了？
示例：如果想把某個介面的實現類作為引數傳遞給一個方法會怎麼做？
Java8以前
public static void general() { // 用匿名內部類的方式來建立執行緒 new Thread(new Runnable() { @Override public void run() { System.out.println("公眾號：風塵部落格！"); } }).run(); }
Lambda寫法
public static void lambda() {
// 使用Lambda來建立執行緒
new Thread(() -> System.out.println("公眾號：風塵部落格！")).run();
}1.2 Lambda表示式是什麼？
Java中，將方法作為引數進行傳遞的方式被稱為Lambda表示式。
1.3 Lambda 表示式語法結構
Lambda其實是一個箭頭函式，也可稱為匿名函式:->
箭頭操作符將Lambda表示式分成了兩部分：
- 左側：
Lambda表示式的引數列表(介面中抽象方法的引數列表) - 右側：
Lambda表示式中所需執行的功能(Lambda體，對抽象方法的實現)
1.4 語法格式
- 無參，無返回值，
Lambda體只需一條語句。
public static void noParam() {
Runnable r1 = () -> System.out.println("noParam Test!");
r1.run();
}Lambda需要一個引數，引數的小括號可以省略。
public static void oneParam() { // Consumer<String> con = (s) -> System.out.println(s); // 引數的小括號可以省略。 Consumer<String> con = s -> System.out.println(s); con.accept("oneParam Test!"); }
Lambda需要多個引數，並且有返回值。
public static void params() {
Comparator<Integer> com = (x, y) -> {
System.out.println("函式式介面");
// 比較x/y的大小
return Integer.compare(x, y);
};
System.out.println(com.compare(1, 2));
}- 當
Lambda體只有一條語句時，return與大括號可以省略。
public static void one() {
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
System.out.println(com.compare(1, 2));
}上面幾條示例好像有一個共性：引數列表的資料型別都沒寫，這是為什麼呢？
1.5 型別推斷
Lambda 表示式中的引數型別都是由編譯器推斷得出的。
public static void typeInference() {
//Integer 型別可以省略
Comparator<Integer> com = (Integer x,Integer y) -> {
System.out.println("函式式介面");
return Integer.compare(x, y);
};
// 型別推斷
BinaryOperator<Long> addImplicit = (x, y) -> x + y;
}Lambda 表示式中無需指定型別，程式依然可 以編譯，這是因為 javac根據程式的上下文，在後臺 推斷出了引數的型別。Lambda 表示式的型別依賴於上下文環境，是由編譯器推斷出來的。
1.6 小節
Lambda表示式使得Java擁有了函數語言程式設計的能力，但在Java中Lambda表示式是物件，它必須依附於一類特別的物件型別——函式式介面(functional interface)。
二、函式式介面
函式介面是隻有一個抽象方法的介面，用作 Lambda 表示式的型別。使用@FunctionalInterface註解修飾的類，編譯器會檢測該類是否只有一個抽象方法或介面，否則，會報錯。可以有多個預設方法，靜態方法。
JDK8在 java.util.function 中定義了幾個標準的函式式介面，供我們使用。
2.1 Java 內建四大核心函式式介面
| 函式式介面 | 引數型別 | 返回型別 | 用途 |
|---|---|---|---|
| Consumer<T> | T | void | 對型別為T的物件應用操作，包含方法：void accept(T t) |
| Supplier<T> | 無 | T | 返回型別為T的物件，包 含方法：T get(); |
| Function<T,R> | T | R | 對型別為T的物件應用操作，並返回結果。結果是R型別的物件。包含方法：R apply(T t); |
| Predicate<T> | T | boolean | 確定型別為T的物件是否滿足某約束，並返回 boolean 值。包含方法 boolean test(T t); |
- 消費型介面
void accept(T t);
consumerDemo(3, s -> System.out.println(s * 3));
public static void consumerDemo(Integer value, Consumer<Integer> consumer) {
consumer.accept(value);
} - 供給型介面
T get();
// 生成10個以內的隨機書
List<Integer> numList = supplierDemo(10, () -> (int)(100 * Math.random()));
System.out.println(numList);
public static List<Integer> supplierDemo(int num, Supplier<Integer> supplier) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
Integer n = supplier.get();
list.add(n);
}
return list;
} - 函式型介面
R apply(T t);
// 處理字串
String str1 = functionDemo("Hello!風塵部落格", s -> s.substring(6));
System.out.println(str1);
String str2 = functionDemo("vanDusty", s -> s.toUpperCase());
System.out.println(str2);
public static String functionDemo(String str, Function<String, String> function) {
return function.apply(str);
}- 斷言型介面
boolean test(T t);
// 將滿足條件的字串放入集合
List<String> list = Arrays.asList("hello", "van", "function", "predicate");
List<String> newList = predicateDemo(list, s -> s.length() > 5);
System.out.println(newList);
public static List<String> predicateDemo(List<String> list, Predicate<String> predicate) {
List<String> newList = new ArrayList<>();
for (String s : list) {
if (predicate.test(s)) {
newList.add(s);
}
}
return newList;
}2.2 自定義函式式介面
我們可以在任意函式式介面上使用 @FunctionalInterface 註解， 這樣做可以檢查它是否是一個函式式介面，同時 javadoc 也會包含一條宣告，說明這個介面是一個函式式介面。
// 字串轉大寫
String newStr = selfFunctionalInterface((str) -> str.toUpperCase(), "abc");
System.out.println(newStr);
public static String selfFunctionalInterface(SelfFunctionalInterface<String> selfFunctionalInterface, String str) {
return selfFunctionalInterface.getValue(str);
}三、方法引用和構造器引用
3.1 方法引用
方法引用是指通過方法的名字來指向一個方法。
3.1.1 方法引用使用的前提條件是什麼呢？
- 方法引用所引用的方法的引數列表必須要和函式式介面中抽象方法的引數列表相同（完全一致）；
- 方法引用所引用的方法的的返回值必須要和函式式介面中抽象方法的返回值相同（完全一致）。
3.1.2 方法引用三種格式
例項物件名::例項方法名
private static void instanceMethod() {
UserDomain user = new UserDomain(1L, "Van");
Supplier<String> sup = () -> user.getUserName();
System.out.println(sup.get());
// 等同於
Supplier<String> supplier = user::getUserName;
System.out.println(supplier.get());
}類名::靜態方法名
private static void staticMethod() {
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
System.out.println(com.compare(3,9));
// 等同於
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(3,9));
}類名::例項方法名
private static void instanceMethodObject() {
UserDomain user = new UserDomain(1L, "Van");
Function<UserDomain, String> fun = (e) -> e.getUserName();
System.out.println(fun.apply(user));
// 等同於
Function<UserDomain, String> fun2 = UserDomain::getUserName;
System.out.println(fun2.apply(user));
}3.2 構造器引用
- 前提：構造器引數列表要與介面中抽象方法的引數列表一致！
- 語法格式：
類名 :: new
- 構造器引用
private static void object() {
// UserDomain 中必須有一個 UserDomain(String userName) 的構造器,下同
Function<String,UserDomain> fun = (n) -> new UserDomain(n);
fun.apply("Van");
System.out.println("===等價於===");
Function<String,UserDomain> function = UserDomain::new;
function.apply("Van");
// 帶兩個引數的構造器引用就要用BiFunction，多個引數的話，還可以自定義一個這樣的函式式介面
BiConsumer<Long, String> biConsumer = UserDomain :: new;
biConsumer.accept(1L,"Van");
}- 陣列引用
private static void array() {
//傳統Lambda實現
Function<Integer,int[]> function = (i) -> new int[i];
int[] apply = function.apply(10);
System.out.println(apply.length);
//陣列型別引用實現
function = int[] ::new;
apply = function.apply(100);
System.out.println(apply.length);
}四、 總結
Github 示例程式碼
Lambda表示式是Java對於函數語言程式設計的溫和轉變，面向物件程式設計和函數語言程式設計不是互相對立的，結合使用能夠更加有效地幫助我們管理程式的複雜性。
技術交流
- 風塵部落格
- 風塵部落格-掘金
- 風塵部落格-部落格園
- Github