java day24【Stream流、方法引用】

第一章 Stream流

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

1.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、逐一打印。代碼中並沒有體現使用線性循環或是其他任何算法進行遍歷，我們真正要做的事情內容被更好地體現在代碼中。

1.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 對象（可以有多次轉換），這就允許對其操作可以像鏈條一樣排列，變成一個管道。

1.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，使用很簡單：

import java.util.stream.Stream;
​
public class Demo06GetStream {
    public static void main(String[] args) {
        String[] array = { "張無忌", "張翠山", "張三豐", "張一元" };
        Stream<String> stream = Stream.of(array);
   }
}

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

1.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);
   }
}

1.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='張二狗'}

1.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中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重復邏輯？

2.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（類型可推導，所以可省略）數據后，在控制台中輸出它。

2.2 問題分析

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

2.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);
   }
}

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

2.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 中 傳遞的參數 一定是方法引用中 的那個方法可以接收的類型,否則會拋出異常

推導與省略

如果使用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)的重載形式。

2.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);
   }
}

2.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

2.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

2.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

2.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

2.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

•