Java語言高級（第六部分）函數式接口 Stream流、方法引用 -＞（個人學習記錄筆記）

第一章 函數式接口

1.1 概念

函數式接口在Java中是指：有且僅有一個抽象方法的接口。

函數式接口，即適用於函數式編程場景的接口。而Java中的函數式編程體現就是Lambda，所以函數式接口就是可以適用於Lambda使用的接口。只有確保接口中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導。

備注：“語法糖”是指使用更加方便，但是原理不變的代碼語法。例如在遍歷集合時使用的for-each語法，其實
底層的實現原理仍然是迭代器，這便是“語法糖”。從應用層面來講，Java中的Lambda可以被當做是匿名內部
類的“語法糖”，但是二者在原理上是不同的。

1.2 格式

只要確保接口中有且僅有一個抽象方法即可：

修飾符 interface 接口名稱 {
    public abstract 返回值類型 方法名稱(可選參數信息);
    // 其他非抽象方法內容
}

由於接口當中抽象方法的 public abstract 是可以省略的，所以定義一個函數式接口很簡單：

public interface MyFunctionalInterface {   
	void myMethod();    
}

1.3 @FunctionalInterface注解

與 @Override 注解的作用類似，Java 8中專門為函數式接口引入了一個新的注解： @FunctionalInterface 。該注解可用於一個接口的定義上：

@FunctionalInterface
public interface MyFunctionalInterface {
	void myMethod();    
}

一旦使用該注解來定義接口，編譯器將會強制檢查該接口是否確實有且僅有一個抽象方法，否則將會報錯。需要注意的是，即使不使用該注解，只要滿足函數式接口的定義，這仍然是一個函數式接口，使用起來都一樣。

1.4 自定義函數式接口

對於剛剛定義好的 MyFunctionalInterface 函數式接口，典型使用場景就是作為方法的參數：

public class Demo09FunctionalInterface {   
	// 使用自定義的函數式接口作為方法參數    
	private static void doSomething(MyFunctionalInterface inter) {    
		inter.myMethod(); // 調用自定義的函數式接口方法        
	}    
   
	public static void main(String[] args) {    
		// 調用使用函數式接口的方法        
		doSomething(() ‐> System.out.println("Lambda執行啦！"));        
	}    
}

---

---

---

/*
    函數式接口:有且只有一個抽象方法的接口,稱之為函數式接口
    當然接口中可以包含其他的方法(默認,靜態,私有)

    @FunctionalInterface注解
    作用:可以檢測接口是否是一個函數式接口
        是:編譯成功
        否:編譯失敗(接口中沒有抽象方法抽象方法的個數多余1個)
 */
@FunctionalInterface
public interface MyFunctionalInterface {
    //定義一個抽象方法
    public abstract void method();
}

/*
    @Override注解
    檢查方法是否為重寫的方法
        是:編譯成功
        否:編譯失敗
 */
public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
    @Override
    public void method() {

    }

    /*@Override
    public void method2() {

    }*/

    /*@Override
    public void method3() {

    }*/
}

/*
    函數式接口的使用:一般可以作為方法的參數和返回值類型
 */
public class Demo {
    //定義一個方法,參數使用函數式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter){
        myInter.method();
    }

    public static void main(String[] args) {
        //調用show方法,方法的參數是一個接口,所以可以傳遞接口的實現類對象
        show(new MyFunctionalInterfaceImpl());

        //調用show方法,方法的參數是一個接口,所以我們可以傳遞接口的匿名內部類
        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名內部類重寫接口中的抽象方法");
            }
        });

        //調用show方法,方法的參數是一個函數式接口,所以我們可以Lambda表達式
        show(()->{
            System.out.println("使用Lambda表達式重寫接口中的抽象方法");
        });

        //簡化Lambda表達式
        show(()-> System.out.println("使用Lambda表達式重寫接口中的抽象方法"));
    }
}

第二章 函數式編程

在兼顧面向對象特性的基礎上，Java語言通過Lambda表達式與方法引用等，為開發者打開了函數式編程的大門。

下面我們做一個初探。

2.1 Lambda的延遲執行

有些場景的代碼執行后，結果不一定會被使用，從而造成性能浪費。而Lambda表達式是延遲執行的，這正好可以作為解決方案，提升性能。

性能浪費的日志案例

注:日志可以幫助我們快速的定位問題，記錄程序運行過程中的情況，以便項目的監控和優化。一種典型的場景就是對參數進行有條件使用，例如對日志消息進行拼接后，在滿足條件的情況下進行打印輸出：

public class Demo01Logger {
    private static void log(int level, String msg) {
        if (level == 1) {
           System.out.println(msg);  
        }
    }
    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(1, msgA + msgB + msgC);
    }
}

這段代碼存在問題：無論級別是否滿足要求，作為 log 方法的第二個參數，三個字符串一定會首先被拼接並傳入方法內，然后才會進行級別判斷。如果級別不符合要求，那么字符串的拼接操作就白做了，存在性能浪費。

備注：SLF4J是應用非常廣泛的日志框架，它在記錄日志時為了解決這種性能浪費的問題，並不推薦首先進行字符串的拼接，而是將字符串的若干部分作為可變參數傳入方法中，僅在日志級別滿足要求的情況下才會進行字符串拼接。例如： LOGGER.debug("變量{}的取值為{}。", "os", "macOS") ，其中的大括號 {} 為占位符。如果滿足日志級別要求，則會將“os”和“macOS”兩個字符串依次拼接到大括號的位置；否則不會進行字符串拼接。這也是一種可行解決方案，但Lambda可以做到更好。

/*
    日志案例

    發現以下代碼存在的一些性能浪費的問題
    調用showLog方法,傳遞的第二個參數是一個拼接后的字符串
    先把字符串拼接好,然后在調用showLog方法
    showLog方法中如果傳遞的日志等級不是1級
    那么就不會是如此拼接后的字符串
    所以感覺字符串就白拼接了,存在了浪費
 */
public class Demo01Logger {
    //定義一個根據日志的級別,顯示日志信息的方法
    public static void showLog(int level, String message){
        //對日志的等級進行判斷,如果是1級別,那么輸出日志信息
        if(level==1){
            System.out.println(message);
        }
    }

    public static void main(String[] args) {
        //定義三個日志信息
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        //調用showLog方法,傳遞日志級別和日志信息
        showLog(2,msg1+msg2+msg3);

    }
}

體驗Lambda的更優寫法

使用Lambda必然需要一個函數式接口：

@FunctionalInterface
public interface MessageBuilder { 
   String buildMessage(); 
}

然后對 log 方法進行改造：

public class Demo02LoggerLambda {
    private static void log(int level, MessageBuilder builder) {
        if (level == 1) {
           System.out.println(builder.buildMessage());  
        }
    }
    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(1, () ‐> msgA + msgB + msgC );
    }
}

這樣一來，只有當級別滿足要求的時候，才會進行三個字符串的拼接；否則三個字符串將不會進行拼接。

/*
    使用Lambda優化日志案例
    Lambda的特點:延遲加載
    Lambda的使用前提,必須存在函數式接口
 */
public class Demo02Lambda {
    //定義一個顯示日志的方法,方法的參數傳遞日志的等級和MessageBuilder接口
    public static void showLog(int level, MessageBuilder mb){
        //對日志的等級進行判斷,如果是1級,則調用MessageBuilder接口中的builderMessage方法
        if(level==1){
            System.out.println(mb.builderMessage());
        }
    }

    public static void main(String[] args) {
        //定義三個日志信息
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        //調用showLog方法,參數MessageBuilder是一個函數式接口,所以可以傳遞Lambda表達式
        /*showLog(2,()->{
            //返回一個拼接好的字符串
            return  msg1+msg2+msg3;
        });*/

        /*
            使用Lambda表達式作為參數傳遞,僅僅是把參數傳遞到showLog方法中
            只有滿足條件,日志的等級是1級
                才會調用接口MessageBuilder中的方法builderMessage
                才會進行字符串的拼接
            如果條件不滿足,日志的等級不是1級
                那么MessageBuilder接口中的方法builderMessage也不會執行
                所以拼接字符串的代碼也不會執行
            所以不會存在性能的浪費
         */
        showLog(1,()->{
            System.out.println("不滿足條件不執行");
            //返回一個拼接好的字符串
            return  msg1+msg2+msg3;
        });
    }
}

@FunctionalInterface
public interface MessageBuilder {
    //定義一個拼接消息的抽象方法,返回被拼接的消息
    public abstract String builderMessage();
}

證明Lambda的延遲

下面的代碼可以通過結果進行驗證：

public class Demo03LoggerDelay {
    private static void log(int level, MessageBuilder builder) {
        if (level == 1) {
           System.out.println(builder.buildMessage());  
        }
    }
    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        String msgC = "Java";
        log(2, () ‐> {
            System.out.println("Lambda執行！");
            return msgA + msgB + msgC;
        });
    }
}

從結果中可以看出，在不符合級別要求的情況下, Lambda將不會執行。從而達到節省性能的效果。

擴展：實際上使用內部類也可以達到同樣的效果，只是將代碼操作延遲到了另外一個對象當中通過調用方法來完成。而是否調用其所在方法是在條件判斷之后才執行的。

2.2 使用Lambda作為參數和返回值

如果拋開實現原理不說，Java中的Lambda表達式可以被當作是匿名內部類的替代品。如果方法的參數是一個函數式接口類型，那么就可以使用Lambda表達式進行替代。使用Lambda表達式作為方法參數，其實就是使用函數式接口作為方法參數。

例如 java.lang.Runnable 接口就是一個函數式接口，假設有一個 startThread 方法使用該接口作為參數，那么就
可以使用Lambda進行傳參。這種情況其實和 Thread 類的構造方法參數為 Runnable 沒有本質區別。

public class Demo04Runnable {
    private static void startThread(Runnable task) {
       new Thread(task).start();  
    }
    public static void main(String[] args) {
       startThread(() ‐> System.out.println("線程任務執行！"));  
    }
}

類似地，如果一個方法的返回值類型是一個函數式接口，那么就可以直接返回一個Lambda表達式。當需要通過一個方法來獲取一個 java.util.Comparator 接口類型的對象作為排序器時,就可以調該方法獲取。

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
    private static Comparator<String> newComparator() {
       return (a, b) ‐> b.length() ‐ a.length();  
    }
    public static void main(String[] args) {
        String[] array = { "abc", "ab", "abcd" };
        System.out.println(Arrays.toString(array));
        Arrays.sort(array, newComparator());
        System.out.println(Arrays.toString(array));
    }
}

其中直接return一個Lambda表達式即可。

第三章 常用函數式接口

JDK提供了大量常用的函數式接口以豐富Lambda的典型使用場景，它們主要在 java.util.function 包中被提供。

下面是最簡單的幾個接口及使用示例。

3.1 Supplier接口

java.util.function.Supplier<T> 接口僅包含一個無參的方法： T get() 。用來獲取一個泛型參數指定類型的對
象數據。由於這是一個函數式接口，這也就意味着對應的Lambda表達式需要“對外提供”一個符合泛型類型的對象
數據。

import java.util.function.Supplier;
public class Demo08Supplier {
    private static String getString(Supplier<String> function) {
       return function.get();  
    }
    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        System.out.println(getString(() ‐> msgA + msgB));
    }
}

3.2 練習：求數組元素最大值

題目

使用 Supplier 接口作為方法參數類型，通過Lambda表達式求出int數組中的最大值。提示：接口的泛型請使用java.lang.Integer 類。

解答

public class Demo02Test {
    //定一個方法,方法的參數傳遞Supplier,泛型使用Integer
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
    public static void main(String[] args) {
        int arr[] = {2,3,4,52,333,23};
        //調用getMax方法,參數傳遞Lambda
        int maxNum = getMax(()‐>{
           //計算數組的最大值
           int max = arr[0];
           for(int i : arr){
               if(i>max){
                   max = i;
               }
           }
           return max;
        });
        System.out.println(maxNum);
    }
}

3.3 Consumer接口

java.util.function.Consumer<T> 接口則正好與Supplier接口相反，它不是生產一個數據，而是消費一個數據，其數據類型由泛型決定。

抽象方法：accept

Consumer 接口中包含抽象方法 void accept(T t) ，意為消費一個指定泛型的數據。基本使用如：

import java.util.function.Consumer;
public class Demo09Consumer {
    private static void consumeString(Consumer<String> function) {
       function.accept("Hello");  
    }
    public static void main(String[] args) {
        consumeString(s ‐> System.out.println(s));
    }
}

當然，更好的寫法是使用方法引用。

默認方法：andThen

如果一個方法的參數和返回值全都是 Consumer 類型，那么就可以實現效果：消費數據的時候，首先做一個操作，然后再做一個操作，實現組合。而這個方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代碼：

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) ‐> { accept(t); after.accept(t); };
}

備注： java.util.Objects 的 requireNonNull 靜態方法將會在參數為null時主動拋出
NullPointerException 異常。這省去了重復編寫if語句和拋出空指針異常的麻煩。

要想實現組合，需要兩個或多個Lambda表達式即可，而 andThen 的語義正是“一步接一步”操作。例如兩個步驟組合的情況：

import java.util.function.Consumer;
public class Demo10ConsumerAndThen {
    private static void consumeString(Consumer<String> one, Consumer<String> two) {
       one.andThen(two).accept("Hello");  
    }
    public static void main(String[] args) {
        consumeString(
            s ‐> System.out.println(s.toUpperCase()),
            s ‐> System.out.println(s.toLowerCase()));
    }
}

運行結果將會首先打印完全大寫的HELLO，然后打印完全小寫的hello。當然，通過鏈式寫法可以實現更多步驟的組合。

3.4 練習：格式化打印信息

題目

下面的字符串數組當中存有多條信息，請按照格式“ 姓名：XX。性別：XX。 ”的格式將信息打印出來。要求將打印姓名的動作作為第一個 Consumer 接口的Lambda實例，將打印性別的動作作為第二個 Consumer 接口的Lambda實例，將兩個 Consumer 接口按照順序“拼接”到一起。

public static void main(String[] args) {
   String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男" };  
}

解答

import java.util.function.Consumer;
public class DemoConsumer {
    public static void main(String[] args) {
        String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男" };
        printInfo(s ‐> System.out.print("姓名：" + s.split(",")[0]),
                  s ‐> System.out.println("。性別：" + s.split(",")[1] + "。"),
                  array);
    }
    private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {
        for (String info : array) {
            one.andThen(two).accept(info); // 姓名：迪麗熱巴。性別：女。
        }
    }
}

3.5 Predicate接口

有時候我們需要對某種類型的數據進行判斷，從而得到一個boolean值結果。這時可以使用 java.util.function.Predicate<T> 接口。

抽象方法：test

Predicate 接口中包含一個抽象方法： boolean test(T t) 。用於條件判斷的場景：

import java.util.function.Predicate;
public class Demo15PredicateTest {
    private static void method(Predicate<String> predicate) {
        boolean veryLong = predicate.test("HelloWorld");
        System.out.println("字符串很長嗎：" + veryLong);
    }
    public static void main(String[] args) {
        method(s ‐> s.length() > 5);
    }
}

條件判斷的標准是傳入的Lambda表達式邏輯，只要字符串長度大於5則認為很長。

默認方法：and

既然是條件判斷，就會存在與、或、非三種常見的邏輯關系。其中將兩個Predicate 條件使用“與”邏輯連接起來實現“並且”的效果時，可以使用default方法 and 。其JDK源碼為：

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> test(t) && other.test(t);
}

如果要判斷一個字符串既要包含大寫“H”，又要包含大寫“W”，那么：

import java.util.function.Predicate;
public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.and(two).test("Helloworld");
        System.out.println("字符串符合要求嗎：" + isValid);
    }
    public static void main(String[] args) {
        method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

默認方法：or

與 and 的“與”類似，默認方法 or 實現邏輯關系中的“或”。JDK源碼為：

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> test(t) || other.test(t);
}

如果希望實現邏輯“字符串包含大寫H或者包含大寫W”，那么代碼只需要將“and”修改為“or”名稱即可，其他都不變：

import java.util.function.Predicate;
public class Demo16PredicateAnd {
    private static void method(Predicate<String> one, Predicate<String> two) {
        boolean isValid = one.or(two).test("Helloworld");
        System.out.println("字符串符合要求嗎：" + isValid);
    }
    public static void main(String[] args) {
        method(s ‐> s.contains("H"), s ‐> s.contains("W"));
    }
}

默認方法：negate

“與”、“或”已經了解了，剩下的“非”（取反）也會簡單。默認方法 negate 的JDK源代碼為：

default Predicate<T> negate() {
    return (t) ‐> !test(t);
}

從實現中很容易看出，它是執行了test方法之后，對結果boolean值進行“!”取反而已。一定要在 test 方法調用之前調用 negate 方法，正如 and 和 or 方法一樣：

import java.util.function.Predicate;
public class Demo17PredicateNegate {
    private static void method(Predicate<String> predicate) {
        boolean veryLong = predicate.negate().test("HelloWorld");
        System.out.println("字符串很長嗎：" + veryLong);
    }
    public static void main(String[] args) {
       method(s ‐> s.length() < 5);  
    }
}

3.6 練習：集合信息篩選

題目

數組當中有多條“姓名+性別”的信息如下，請通過 Predicate 接口的拼裝將符合要求的字符串篩選到集合ArrayList 中，需要同時滿足兩個條件：

1. 必須為女生；
2. 姓名為4個字。

public class DemoPredicate {
    public static void main(String[] args) {
       String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男", "趙麗穎,女" };  
    }
}

解答

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class DemoPredicate {
    public static void main(String[] args) {
        String[] array = { "迪麗熱巴,女", "古力娜扎,女", "馬爾扎哈,男", "趙麗穎,女" };
        List<String> list = filter(array,
                                   s ‐> "女".equals(s.split(",")[1]),
                                   s ‐> s.split(",")[0].length() == 4);
        System.out.println(list);
    }
    private static List<String> filter(String[] array, Predicate<String> one,
                                       Predicate<String> two) {
        List<String> list = new ArrayList<>();
        for (String info : array) {
            if (one.and(two).test(info)) {
                list.add(info);
            }
        }
        return list;
    }
}

3.7 Function接口

java.util.function.Function<T,R> 接口用來根據一個類型的數據得到另一個類型的數據，前者稱為前置條件，后者稱為后置條件。

抽象方法：apply

Function 接口中最主要的抽象方法為： R apply(T t) ，根據類型T的參數獲取類型R的結果。使用的場景例如：將 String 類型轉換為 Integer 類型。

import java.util.function.Function;
public class Demo11FunctionApply {
    private static void method(Function<String, Integer> function) {
        int num = function.apply("10");
        System.out.println(num + 20);
    }
    public static void main(String[] args) {
        method(s ‐> Integer.parseInt(s));
    }
}

當然，最好是通過方法引用的寫法。

默認方法：andThen

Function 接口中有一個默認的 andThen 方法，用來進行組合操作。JDK源代碼如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) ‐> after.apply(apply(t));
}

該方法同樣用於“先做什么，再做什么”的場景，和 Consumer 中的 andThen 差不多：

import java.util.function.Function;
public class Demo12FunctionAndThen {
    private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
        int num = one.andThen(two).apply("10");
        System.out.println(num + 20);
    }
    public static void main(String[] args) {
        method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
    }
}

第一個操作是將字符串解析成為int數字，第二個操作是乘以10。兩個操作通過 andThen 按照前后順序組合到了一起。

請注意，Function的前置條件泛型和后置條件泛型可以相同。

3.8 練習：自定義函數模型拼接

題目

請使用 Function 進行函數模型的拼接，按照順序需要執行的多個函數操作為：
String str = "趙麗穎,20";

1. 將字符串截取數字年齡部分，得到字符串；
2. 將上一步的字符串轉換成為int類型的數字；
3. 將上一步的int數字累加100，得到結果int數字。

解答

import java.util.function.Function;
public class DemoFunction {
    public static void main(String[] args) {
        String str = "趙麗穎,20";
        int age = getAgeNum(str, s ‐> s.split(",")[1],
                            s ‐>Integer.parseInt(s),
                            n ‐> n += 100);
        System.out.println(age);
    }
    private static int getAgeNum(String str, Function<String, String> one,
                                 Function<String, Integer> two,
                                 Function<Integer, Integer> three) {
        return one.andThen(two).andThen(three).apply(str);
    }
}

第四章 Stream流

說到Stream便容易想到I/O Stream，而實際上，誰規定“流”就一定是“IO流”呢？在Java 8中，得益於Lambda所帶來的函數式編程，引入了一個全新的Stream概念，用於解決已有集合類庫既有的弊端。

4.1 引言

傳統集合的多步遍歷代碼

幾乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或間接的遍歷操作。而當我們需要對集合中的元素進行操作的時候，除了必需的添加、刪除、獲取外，最典型的就是集合遍歷。例如：

import java.util.ArrayList;
import java.util.List;
public class Demo01ForEach {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("張無忌");
        list.add("周芷若");
        list.add("趙敏");
        list.add("張強");
        list.add("張三豐");
        for (String name : list) {
           System.out.println(name);  
        }
    } 
}

這是一段非常簡單的集合遍歷操作：對集合中的每一個字符串都進行打印輸出操作。

循環遍歷的弊端

Java 8的Lambda讓我們可以更加專注於做什么（What），而不是怎么做（How），這點此前已經結合內部類進行了對比說明。現在，我們仔細體會一下上例代碼，可以發現：

• for循環的語法就是“怎么做”
• for循環的循環體才是“做什么”

為什么使用循環？因為要進行遍歷。但循環是遍歷的唯一方式嗎？遍歷是指每一個元素逐一進行處理，而並不是從第一個到最后一個順次處理的循環。前者是目的，后者是方式。

試想一下，如果希望對集合中的元素進行篩選過濾：

1. 將集合A根據條件一過濾為子集B；
2. 然后再根據條件二過濾為子集C。

那怎么辦？在Java 8之前的做法可能為：

import java.util.ArrayList;
import java.util.List;
public class Demo02NormalFilter {
   public static void main(String[] args) {  
       List<String> list = new ArrayList<>();  
        list.add("張無忌");
        list.add("周芷若");
        list.add("趙敏");
        list.add("張強");
        list.add("張三豐");
        List<String> zhangList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("張")) {
               zhangList.add(name);  
            }
        }
        List<String> shortList = new ArrayList<>();
        for (String name : zhangList) {
            if (name.length() == 3) {
               shortList.add(name);  
            }
        }
        for (String name : shortList) {
           System.out.println(name);  
        }
    }
}

這段代碼中含有三個循環，每一個作用不同：

1. 首先篩選所有姓張的人；
2. 然后篩選名字有三個字的人；
3. 最后進行對結果進行打印輸出。

每當我們需要對集合中的元素進行操作的時候，總是需要進行循環、循環、再循環。這是理所當然的么？不是。循環是做事情的方式，而不是目的。另一方面，使用線性循環就意味着只能遍歷一次。如果希望再次遍歷，只能再使用另一個循環從頭開始。

那，Lambda的衍生物Stream能給我們帶來怎樣更加優雅的寫法呢？

Stream的更優寫法

下面來看一下借助Java 8的Stream API，什么才叫優雅：

import java.util.ArrayList;
import java.util.List;
public class Demo03StreamFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("張無忌");
        list.add("周芷若");
        list.add("趙敏");
        list.add("張強");
        list.add("張三豐");
        list.stream()
           .filter(s ‐> s.startsWith("張"))  
            .filter(s ‐> s.length() == 3)
            .forEach(System.out::println);
    }
}

直接閱讀代碼的字面意思即可完美展示無關邏輯方式的語義：獲取流、過濾姓張、過濾長度為3、逐一打印。 代碼中並沒有體現使用線性循環或是其他任何算法進行遍歷，我們真正要做的事情內容被更好地體現在代碼中。

4.2 流式思想概述

注意：請暫時忘記對傳統IO流的固有印象！

當需要對多個元素進行操作（特別是多步操作）的時候，考慮到性能及便利性，我們應該首先拼好一個“模型”步驟方案，然后再按照方案去執行它。

在這里插入圖片描述

這張圖中展示了過濾、映射、跳過、計數等多步操作，這是一種集合元素的處理方案，而方案就是一種“函數模型”。圖中的每一個方框都是一個“流”，調用指定的方法，可以從一個流模型轉換為另一個流模型。而最右側的數字3是最終結果。

這里的 filter 、 map 、 skip 都是在對函數模型進行操作，集合元素並沒有真正被處理。只有當終結方法 count執行的時候，整個模型才會按照指定策略執行操作。而這得益於Lambda的延遲執行特性。

備注：“Stream流”其實是一個集合元素的函數模型，它並不是集合，也不是數據結構，其本身並不存儲任何元素（或其地址值）。

Stream（流）是一個來自數據源的元素隊列

• 元素是特定類型的對象，形成一個隊列。 Java中的Stream並不會存儲元素，而是按需計算。
• 數據源 流的來源。 可以是集合，數組 等。

和以前的Collection操作不同， Stream操作還有兩個基礎的特征：

• Pipelining: 中間操作都會返回流對象本身。 這樣多個操作可以串聯成一個管道， 如同流式風格（fluent style）。這樣做可以對操作進行優化， 比如延遲執行(laziness)和短路( short-circuiting)。
• 內部迭代：以前對集合遍歷都是通過Iterator或者增強for的方式, 顯式的在集合外部進行迭代， 這叫做外部迭 代。Stream提供了內部迭代的方式，流可以直接調用遍歷方法。

當使用一個流的時候，通常包括三個基本步驟：獲取一個數據源（source）→ 數據轉換→執行操作獲取想要的結果，每次轉換原有 Stream 對象不改變，返回一個新的 Stream 對象（可以有多次轉換），這就允許對其操作可以像鏈條一樣排列，變成一個管道。

4.3 獲取流

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。（這並不是一個函數式接口。）
獲取一個流非常簡單，有以下幾種常用的方式：

• 所有的 Collection 集合都可以通過 stream 默認方法獲取流；
• Stream 接口的靜態方法 of 可以獲取數組對應的流。

根據Collection獲取流

首先， java.util.Collection 接口中加入了default方法 stream 用來獲取流，所以其所有實現類均可獲取流。

import java.util.*;
import java.util.stream.Stream;
public class Demo04GetStream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // ...
        Stream<String> stream1 = list.stream();
        Set<String> set = new HashSet<>();
        // ...
        Stream<String> stream2 = set.stream();
        Vector<String> vector = new Vector<>();
        // ...
         Stream<String> stream3 = vector.stream();
    }
}

根據Map獲取流

java.util.Map 接口不是 Collection 的子接口，且其K-V數據結構不符合流元素的單一特征，所以獲取對應的流需要分key、value或entry等情況：

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
public class Demo05GetStream {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        // ...
        Stream<String> keyStream = map.keySet().stream();
        Stream<String> valueStream = map.values().stream();
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
    }
}

根據數組獲取流

如果使用的不是集合或映射而是數組，由於數組對象不可能添加默認方法，所以 Stream 接口中提供了靜態方法of ，使用很簡單：

備注： of 方法的參數其實是一個可變參數，所以支持數組。

4.4 常用方法

在這里插入圖片描述

流模型的操作很豐富，這里介紹一些常用的API。這些方法可以被分成兩種：

• 延遲方法：返回值類型仍然是 Stream 接口自身類型的方法，因此支持鏈式調用。（除了終結方法外，其余方 法均為延遲方法。）
• 終結方法：返回值類型不再是 Stream 接口自身類型的方法，因此不再支持類似 StringBuilder 那樣的鏈式調用。本小節中，終結方法包括 count 和 forEach 方法。

備注：本小節之外的更多方法，請自行參考API文檔。

逐一處理：forEach

雖然方法名字叫 forEach ，但是與for循環中的“for-each”昵稱不同。

void forEach(Consumer<? super T> action);

該方法接收一個 Consumer 接口函數，會將每一個流元素交給該函數進行處理。

復習Consumer接口

java.util.function.Consumer<T>接口是一個消費型接口。
Consumer接口中包含抽象方法void accept(T t)，意為消費一個指定泛型的數據。

基本使用：

import java.util.stream.Stream;
public class Demo12StreamForEach {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("張無忌", "張三豐", "周芷若");
        stream.forEach(name‐> System.out.println(name));
    }
}

過濾：filter

可以通過 filter 方法將一個流轉換成另一個子集流。方法簽名：

Stream<T> filter(Predicate<? super T> predicate);

該接口接收一個 Predicate 函數式接口參數（可以是一個Lambda或方法引用）作為篩選條件。

在這里插入圖片描述

復習Predicate接口

此前我們已經學習過 java.util.stream.Predicate 函數式接口，其中唯一的抽象方法為：

boolean test(T t);

該方法將會產生一個boolean值結果，代表指定的條件是否滿足。如果結果為true，那么Stream流的 filter 方法將會留用元素；如果結果為false，那么 filter 方法將會舍棄元素。

基本使用

Stream流中的 filter 方法基本使用的代碼如：

import java.util.stream.Stream;
public class Demo07StreamFilter {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
        Stream<String> result = original.filter(s ‐> s.startsWith("張"));
    }
}

在這里通過Lambda表達式來指定了篩選的條件：必須姓張。

映射：map

如果需要將流中的元素映射到另一個流中，可以使用 map 方法。方法簽名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

該接口需要一個 Function 函數式接口參數，可以將當前流中的T類型數據轉換為另一種R類型的流。
在這里插入圖片描述

復習Function接口

此前我們已經學習過 java.util.stream.Function 函數式接口，其中唯一的抽象方法為：

R apply(T t);

這可以將一種T類型轉換成為R類型，而這種轉換的動作，就稱為“映射”。

基本使用

Stream流中的 map 方法基本使用的代碼如：

import java.util.stream.Stream;
public class Demo08StreamMap {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("10", "12", "18");
        Stream<Integer> result = original.map(str‐>Integer.parseInt(str));
    }
}

這段代碼中， map 方法的參數通過方法引用，將字符串類型轉換成為了int類型（並自動裝箱為 Integer 類對象）。

統計個數：count

正如舊集合 Collection 當中的 size 方法一樣，流提供 count 方法來數一數其中的元素個數：

long count();

該方法返回一個long值代表元素個數（不再像舊集合那樣是int值）。基本使用：

import java.util.stream.Stream;
public class Demo09StreamCount {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
        Stream<String> result = original.filter(s ‐> s.startsWith("張"));
        System.out.println(result.count()); // 2
    }
}

取用前幾個：limit

limit 方法可以對流進行截取，只取用前n個。方法簽名：

Stream<T> limit(long maxSize);

參數是一個long型，如果集合當前長度大於參數則進行截取；否則不進行操作。基本使用：
在這里插入圖片描述

import java.util.stream.Stream;
public class Demo10StreamLimit {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
        Stream<String> result = original.limit(2);
        System.out.println(result.count()); // 2
    }
}

跳過前幾個：skip

如果希望跳過前幾個元素，可以使用 skip 方法獲取一個截取之后的新流：

Stream<T> skip(long n);

如果流的當前長度大於n，則跳過前n個；否則將會得到一個長度為0的空流。基本使用：

在這里插入圖片描述

import java.util.stream.Stream;
public class Demo11StreamSkip {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("張無忌", "張三豐", "周芷若");
        Stream<String> result = original.skip(2);
        System.out.println(result.count()); // 1
    }
}

組合：concat

如果有兩個流，希望合並成為一個流，那么可以使用 Stream 接口的靜態方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

備注：這是一個靜態方法，與 java.lang.String 當中的 concat 方法是不同的。

該方法的基本使用代碼如：

import java.util.stream.Stream;
public class Demo12StreamConcat {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("張無忌");
        Stream<String> streamB = Stream.of("張翠山");
        Stream<String> result = Stream.concat(streamA, streamB);
    }
}

4.5 練習：集合元素處理（傳統方式）

題目

現在有兩個 ArrayList 集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以下若干操作步驟：

1. 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
2. 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
3. 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
4. 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
5. 將兩個隊伍合並為一個隊伍；存儲到一個新集合中。
6. 根據姓名創建 Person 對象；存儲到一個新集合中。
7. 打印整個隊伍的Person對象信息。

兩個隊伍（集合）的代碼如下：

import java.util.ArrayList;
import java.util.List;
public class DemoArrayListNames {
    public static void main(String[] args) {
       //第一支隊伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪麗熱巴");
        one.add("宋遠橋");
        one.add("蘇星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        //第二支隊伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("張無忌");
        two.add("趙麗穎");
        two.add("張三豐");
        two.add("尼古拉斯趙四");
        two.add("張天愛");
        two.add("張二狗");
// ....        
    }
}

而 Person 類的代碼為：

public class Person {
   
    private String name;
    public Person() {}
    public Person(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

解答

既然使用傳統的for循環寫法，那么：

public class DemoArrayListNames {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        // ...
        List<String> two = new ArrayList<>();
        // ...
        // 第一個隊伍只要名字為3個字的成員姓名；
        List<String> oneA = new ArrayList<>();
        for (String name : one) {
            if (name.length() == 3) {
                oneA.add(name);
            }
        }
        // 第一個隊伍篩選之后只要前3個人；
        List<String> oneB = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            oneB.add(oneA.get(i));
        }
        // 第二個隊伍只要姓張的成員姓名；
        List<String> twoA = new ArrayList<>();
        for (String name : two) {
            if (name.startsWith("張")) {
                twoA.add(name);
            }
        }
        // 第二個隊伍篩選之后不要前2個人；
        List<String> twoB = new ArrayList<>();
        for (int i = 2; i < twoA.size(); i++) {
            twoB.add(twoA.get(i));
        }
        // 將兩個隊伍合並為一個隊伍；
        List<String> totalNames = new ArrayList<>();
        totalNames.addAll(oneB);
        totalNames.addAll(twoB);
        // 根據姓名創建Person對象；
        List<Person> totalPersonList = new ArrayList<>();
        for (String name : totalNames) {
            totalPersonList.add(new Person(name));
        }
        // 打印整個隊伍的Person對象信息。
        for (Person person : totalPersonList) {
            System.out.println(person);
        }
    }
}

運行結果為：

Person{name='宋遠橋'}
Person{name='蘇星河'}
Person{name='石破天'}
Person{name='張天愛'}
Person{name='張二狗'}

4.6 練習：集合元素處理（Stream方式）

題目

將上一題當中的傳統for循環寫法更換為Stream流式處理方式。兩個集合的初始內容不變， Person 類的定義也不變。

解答

等效的Stream流式處理代碼為：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class DemoStreamNames {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        // ...
        List<String> two = new ArrayList<>();
        // ...
        // 第一個隊伍只要名字為3個字的成員姓名；
        // 第一個隊伍篩選之后只要前3個人；
        Stream<String> streamOne = one.stream().filter(s ‐> s.length() == 3).limit(3);
        // 第二個隊伍只要姓張的成員姓名；
        // 第二個隊伍篩選之后不要前2個人；
        Stream<String> streamTwo = two.stream().filter(s ‐> s.startsWith("張")).skip(2);
        // 將兩個隊伍合並為一個隊伍；
        // 根據姓名創建Person對象；
        // 打印整個隊伍的Person對象信息。
        Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
    }
}

運行效果完全一樣：

Person{name='宋遠橋'}
Person{name='蘇星河'}
Person{name='石破天'}
Person{name='張天愛'}
Person{name='張二狗'}

第五章 方法引用

在使用Lambda表達式的時候，我們實際上傳遞進去的代碼就是一種解決方案：拿什么參數做什么操作。那么考慮一種情況：如果我們在Lambda中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重復邏輯？

5.1 冗余的Lambda場景

來看一個簡單的函數式接口以應用Lambda表達式：

@FunctionalInterface
public interface Printable {
   void print(String str);  
}

在 Printable 接口當中唯一的抽象方法 print 接收一個字符串參數，目的就是為了打印顯示它。那么通過Lambda來使用它的代碼很簡單：

public class Demo01PrintSimple {
    private static void printString(Printable data) {
       data.print("Hello, World!");  
    }
    public static void main(String[] args) {
       printString(s ‐> System.out.println(s));  
    }
}

其中 printString 方法只管調用 Printable 接口的 print 方法，而並不管 print 方法的具體實現邏輯會將字符串打印到什么地方去。而 main 方法通過Lambda表達式指定了函數式接口 Printable 的具體操作方案為：拿到String（類型可推導，所以可省略）數據后，在控制台中輸出它。

5.2 問題分析

這段代碼的問題在於，對字符串進行控制台打印輸出的操作方案，明明已經有了現成的實現，那就是 System.out對象中的 println(String) 方法。既然Lambda希望做的事情就是調用 println(String) 方法，那何必自己手動調用呢？

5.3 用方法引用改進代碼

能否省去Lambda的語法格式（盡管它已經相當簡潔）呢？只要“引用”過去就好了：

public class Demo02PrintRef {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
    public static void main(String[] args) {
       printString(System.out::println);  
    }
}

請注意其中的雙冒號 :: 寫法，這被稱為“方法引用”，而雙冒號是一種新的語法。

5.4 方法引用符

雙冒號 :: 為引用運算符，而它所在的表達式被稱為方法引用。如果Lambda要表達的函數方案已經存在於某個方法的實現中，那么則可以通過雙冒號來引用該方法作為Lambda的替代者。

語義分析

例如上例中， System.out 對象中有一個重載的 println(String) 方法恰好就是我們所需要的。那么對於printString 方法的函數式接口參數，對比下面兩種寫法，完全等效：

• Lambda表達式寫法： s -> System.out.println(s);
• 方法引用寫法： System.out::println

第一種語義是指：拿到參數之后經Lambda之手，，繼而傳遞給 System.out.println 方法去處理。
第二種等效寫法的語義是指：直接讓 System.out 中的 println 方法來取代Lambda。兩種寫法的執行效果完全一樣，而第二種方法引用的寫法復用了已有方案，更加簡潔。

注:Lambda 中 傳遞的參數 一定是方法引用中 的那個方法可以接收的類型,否則會拋出異常

推導與省略

5.5 通過對象名引用成員方法

如果使用Lambda，那么根據“可推導就是可省略”的原則，無需指定參數類型，也無需指定的重載形式——它們都將被自動推導。而如果使用方法引用，也是同樣可以根據上下文進行推導。

函數式接口是Lambda的基礎，而方法引用是Lambda的孿生兄弟。

下面這段代碼將會調用 println 方法的不同重載形式，將函數式接口改為int類型的參數：

@FunctionalInterface
public interface PrintableInteger {
   void print(int str);  
}

由於上下文變了之后可以自動推導出唯一對應的匹配重載，所以方法引用沒有任何變化：

public class Demo03PrintOverload {
    private static void printInteger(PrintableInteger data) {
       data.print(1024);  
    }
    public static void main(String[] args) {
       printInteger(System.out::println);  
    }
}

這次方法引用將會自動匹配到 println(int) 的重載形式。

5.5 通過對象名引用成員方法

這是最常見的一種用法，與上例相同。如果一個類中已經存在了一個成員方法：

public class MethodRefObject {
    public void printUpperCase(String str) {
       System.out.println(str.toUpperCase());  
    }
}

函數式接口仍然定義為：

@FunctionalInterface
public interface Printable {
   void print(String str);  
}

那么當需要使用這個 printUpperCase 成員方法來替代 Printable 接口的Lambda的時候，已經具有了MethodRefObject 類的對象實例，則可以通過對象名引用成員方法，代碼為：

public class Demo04MethodRef {
    private static void printString(Printable lambda) {
       lambda.print("Hello");  
    }
    public static void main(String[] args) {
        MethodRefObject obj = new MethodRefObject();
        printString(obj::printUpperCase);
    }
}

5.6 通過類名稱引用靜態方法

由於在 java.lang.Math 類中已經存在了靜態方法 abs ，所以當我們需要通過Lambda來調用該方法時，有兩種寫法。首先是函數式接口：

@FunctionalInterface
public interface Calcable {
   int calc(int num);  
}

第一種寫法是使用Lambda表達式：

public class Demo05Lambda {
    private static void method(int num, Calcable lambda) {
       System.out.println(lambda.calc(num));  
    }
    public static void main(String[] args) {
       method(‐10, n ‐> Math.abs(n));  
    }
}

但是使用方法引用的更好寫法是：

public class Demo06MethodRef {
    private static void method(int num, Calcable lambda) {
       System.out.println(lambda.calc(num));  
    }
    public static void main(String[] args) {
       method(‐10, Math::abs);  
    }
}

在這個例子中，下面兩種寫法是等效的：

• Lambda表達式： n -> Math.abs(n)
• 方法引用： Math::abs

5.7 通過super引用成員方法

如果存在繼承關系，當Lambda中需要出現super調用時，也可以使用方法引用進行替代。首先是函數式接口：

@FunctionalInterface
public interface Greetable {
   void greet();  
}

然后是父類 Human 的內容：

public class Human {
    public void sayHello() {
       System.out.println("Hello!");  
    }
}

最后是子類 Man 的內容，其中使用了Lambda的寫法：

public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好,我是Man!");
    }
    //定義方法method,參數傳遞Greetable接口
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        //調用method方法,使用Lambda表達式
        method(()‐>{
            //創建Human對象,調用sayHello方法
            new Human().sayHello();
        });
        //簡化Lambda
        method(()‐>new Human().sayHello());
        //使用super關鍵字代替父類對象
        method(()‐>super.sayHello());
    }
}

但是如果使用方法引用來調用父類中的 sayHello 方法會更好，例如另一個子類 Woman ：

public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好,我是Man!");
    }
    //定義方法method,參數傳遞Greetable接口
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        method(super::sayHello);
    }
}

在這個例子中，下面兩種寫法是等效的：

• Lambda表達式： () -> super.sayHello()
• 方法引用： super::sayHello

5.8 通過this引用成員方法

this代表當前對象，如果需要引用的方法就是當前類中的成員方法，那么可以使用“this::成員方法”的格式來使用方法引用。首先是簡單的函數式接口：

@FunctionalInterface
public interface Richable {
   void buy(); 
}

下面是一個丈夫 Husband 類：

public class Husband {
    private void marry(Richable lambda) {
       lambda.buy();  
    }
    public void beHappy() {
       marry(() ‐> System.out.println("買套房子"));  
    }
}

開心方法 beHappy 調用了結婚方法 marry ，后者的參數為函數式接口 Richable ，所以需要一個Lambda表達式。但是如果這個Lambda表達式的內容已經在本類當中存在了，則可以對 Husband 丈夫類進行修改:

public class Husband {
    private void buyHouse() {
       System.out.println("買套房子");  
    }
    private void marry(Richable lambda) {
       lambda.buy();  
    }
    public void beHappy() {
       marry(() ‐> this.buyHouse());  
    }
}

如果希望取消掉Lambda表達式，用方法引用進行替換，則更好的寫法為：

public class Husband {
    private void buyHouse() {
       System.out.println("買套房子");  
    }
    private void marry(Richable lambda) {
       lambda.buy();  
    }
    public void beHappy() {
       marry(this::buyHouse);  
    }
}

在這個例子中，下面兩種寫法是等效的：

• Lambda表達式： () -> this.buyHouse()
• 方法引用： this::buyHouse

5.9 類的構造器引用

由於構造器的名稱與類名完全一樣，並不固定。所以構造器引用使用 類名稱::new 的格式表示。首先是一個簡單的 Person 類：

public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

然后是用來創建 Person 對象的函數式接口：

public interface PersonBuilder {
    Person buildPerson(String name);
}

要使用這個函數式接口，可以通過Lambda表達式：

public class Demo09Lambda {
    public static void printName(String name, PersonBuilder builder) {
       System.out.println(builder.buildPerson(name).getName());  
    }
    public static void main(String[] args) {
       printName("趙麗穎", name ‐> new Person(name));  
    }
}

但是通過構造器引用，有更好的寫法：

public class Demo10ConstructorRef {
    public static void printName(String name, PersonBuilder builder) {
       System.out.println(builder.buildPerson(name).getName());  
    }
    public static void main(String[] args) {
       printName("趙麗穎", Person::new);  
    }
}

在這個例子中，下面兩種寫法是等效的：

• Lambda表達式： name -> new Person(name)
• 方法引用： Person::new

5.10 數組的構造器引用

數組也是 Object 的子類對象，所以同樣具有構造器，只是語法稍有不同。如果對應到Lambda的使用場景中時，需要一個函數式接口：

@FunctionalInterface
public interface ArrayBuilder {
   int[] buildArray(int length);  
}

在應用該接口的時候，可以通過Lambda表達式：

public class Demo11ArrayInitRef {  
    private static int[] initArray(int length, ArrayBuilder builder) {
       return builder.buildArray(length);  
    }
    public static void main(String[] args) {
       int[] array = initArray(10, length ‐> new int[length]);  
    }
}

但是更好的寫法是使用數組的構造器引用：

public class Demo12ArrayInitRef {
    private static int[] initArray(int length, ArrayBuilder builder) {
       return builder.buildArray(length);  
    }
    public static void main(String[] args) {
       int[] array = initArray(10, int[]::new);  
    }
}

在這個例子中，下面兩種寫法是等效的：

• Lambda表達式： length -> new int[length]
• 方法引用： int[]::new