Stream流

全新的Stream概念，用於解決已有集合類庫既有的弊端。

傳統集合的多步遍歷代碼

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

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之前的做法可能為：

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的更優寫法

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

獲取流

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口。（這並不是一個函數式接口。）

獲取一個流非常簡單，有以下幾種常用的方式：

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

根據Collection獲取流

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

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等情況：

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

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<T>接口是一個消費型接口。
Consumer接口中包含抽象方法void accept(T t)，意為消費一個指定泛型的數據。

基本使用：

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 方法基本使用的代碼如：

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 方法基本使用的代碼如：

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值）。基本使用：

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型，如果集合當前長度大於參數則進行截取；否則不進行操作。基本使用：

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的空流。基本使用：

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方法是不同的。
該方法的基本使用代碼如：

Stream<String> streamA = Stream.of("張無忌");
Stream<String> streamB = Stream.of("張翠山");
Stream<String> result = Stream.concat(streamA, streamB)

方法引用

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

冗余的Lambda場景

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

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

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

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的語法格式（盡管它已經相當簡潔）呢？只要“引用”過去就好了：

private static void printString(Printable data) {
    data.print("Hello, World!");
}
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);
}

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

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

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

通過對象名引用成員方法

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

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

函數式接口仍然定義為：

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

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

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表達式：

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

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

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 的內容：

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

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

@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 ：

@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 類：

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

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

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

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

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 類：

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 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 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表達式：

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

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

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

JavaSE復習（七）Stream流和方法引用