Java【Stream流、方法引用】學習筆記

阿新 • • 發佈：2020-07-21

【Stream流、方法引用】

Stream流

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

引言

傳統集合的多步遍歷程式碼

幾乎所有的集合（如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迴圈的迴圈體才是“做什麼”

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

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

將集合A根據條件一過濾為子集B；
然後再根據條件二過濾為子集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);
        }
    }
}

這段程式碼中含有三個迴圈，每一個作用不同：

首先篩選所有姓張的人；
然後篩選名字有三個字的人；
最後進行對結果進行列印輸出。

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

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

流式思想概述

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

整體來看，流式思想類似於工廠車間的“生產流水線”。

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

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

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

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

Stream（流）是一個來自資料來源的元素佇列

元素是特定型別的物件，形成一個佇列。 Java中的Stream並不會儲存元素，而是按需計算。
資料來源 流的來源。可以是集合,陣列等。

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

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

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

獲取流

java.util.stream.Stream是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方法的引數其實是一個可變引數，所以支援陣列。

常用方法

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

延遲方法：返回值型別仍然是Stream介面自身型別的方法，因此支援鏈式呼叫。（除了終結方法外，其餘方法均為延遲方法。）
終結方法：返回值型別不再是Stream介面自身型別的方法，因此不再支援類似StringBuilder那樣的鏈式呼叫。本小節中，終結方法包括count和forEach方法。

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

逐一處理：forEach

雖然方法名字叫forEach，但是與for迴圈中的“for-each”暱稱不同。

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

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

複習Consumer介面

java.util.function.Consumer介面是一個消費型介面。

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();

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

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

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

第一個隊伍只要名字為3個字的成員姓名；儲存到一個新集合中。
第一個隊伍篩選之後只要前3個人；儲存到一個新集合中。
第二個隊伍只要姓張的成員姓名；儲存到一個新集合中。
第二個隊伍篩選之後不要前2個人；儲存到一個新集合中。
將兩個隊伍合併為一個隊伍；儲存到一個新集合中。
根據姓名建立Person物件；儲存到一個新集合中。
列印整個隊伍的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='張二狗'}

練習：集合元素處理（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中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重複邏輯？

冗餘的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（型別可推導，所以可省略）資料後，在控制檯中輸出它。

問題分析

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

用方法引用改進程式碼

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

public class Demo02PrintRef {
    private static void printString(Printable data) {
        data.print("Hello, World!");
    }
    /*
    	分析：
    		Lambda表示式的目的，列印引數傳遞的字串
    		把引數s傳遞給了System.out物件，呼叫out物件中的方法println對字串進行了輸出
    	注意：
    		1.System.out物件是已經存在的
    		2.println物件方法也是已經存在的
    	所以我們可以使用方法引用來優化Lambda表示式
    	可以使用System.out方法直接引用（呼叫）println方法
    */
    public static void main(String[] args) {
        printString(System.out::println);
    }
}

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

方法引用符

雙冒號::為引用運算子，而它所在的表示式被稱為方法引用。如果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)的過載形式。

通過物件名引用成員方法

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

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

通過類名稱引用靜態方法

由於在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

通過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

通過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

類的構造器引用

由於構造器的名稱與類名完全一樣，並不固定。所以構造器引用使用類名稱::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

陣列的構造器引用

陣列也是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

Java【Stream流、方法引用】學習筆記

【Stream流、方法引用】

Stream流

引言

傳統集合的多步遍歷程式碼

迴圈遍歷的弊端

Stream的更優寫法

流式思想概述

獲取流

根據Collection獲取流

根據Map獲取流

根據陣列獲取流

常用方法

逐一處理：forEach

複習Consumer介面

基本使用：

過濾：filter

複習Predicate介面

基本使用

對映：map

複習Function介面

基本使用

統計個數：count

取用前幾個：limit

跳過前幾個：skip

組合：concat

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

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

方法引用

冗餘的Lambda場景

問題分析

用方法引用改進程式碼

方法引用符

語義分析

推導與省略:

通過物件名引用成員方法

通過類名稱引用靜態方法

通過super引用成員方法

通過this引用成員方法

類的構造器引用

陣列的構造器引用

相關推薦