Stream流

• 說到Stream便容易想到I/O Stream，而實(shí)際上，誰規(guī)定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所帶來的函數(shù)式編程，引入了一個全新的Stream概念，用于解決已有集合類庫既有的弊端。
• 當(dāng)需要對多個元素進(jìn)行操作（特別是多步操作）的時候，考慮到性能及便利性，我們應(yīng)該首先拼好一個“模型”步驟方案，然后再按照方案去執(zhí)行它。
• 諸如filter 、 map、 skip都是在對函數(shù)模型進(jìn)行操作，集合元素并沒有真正被處理。只有當(dāng)終結(jié)方法 類似于count,forEach執(zhí)行的時候，整個模型才會按照指定策略執(zhí)行操作。而這得益于Lambda的延遲執(zhí)行特性。就相當(dāng)于現(xiàn)將流水線硬件先建立好，然后再啟動流水線！

“Stream流”其實(shí)是一個集合元素的函數(shù)模型(處理的步驟方法)，它并不是集合，也不是數(shù)據(jù)結(jié)構(gòu)，其本身并不存儲任何元素（或其地址值）。

Stream（流）是一個來自數(shù)據(jù)源的元素隊(duì)列

• 元素是特定類型的對象，形成一個隊(duì)列，Java中的Stream并不會存儲元素，而是按需計(jì)算。
• 數(shù)據(jù)源流的來源，可以使集合、數(shù)組等。

和以前的Collection操作不同， Stream操作還有兩個基礎(chǔ)的特征

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

通常使用流的三個基本步驟

1. 獲取一個數(shù)據(jù)源(Source)
2. 數(shù)據(jù)轉(zhuǎn)換
3. 執(zhí)行操作獲取險要的結(jié)果

每次轉(zhuǎn)換原有 Stream 對象不改變，返回一個新的 Stream 對象（可以有多次轉(zhuǎn)換），這就允許對其操作可以像鏈條一樣排列，變成一個管道

一、獲取流

java.util.stream.Stream<T> 是Java 8新加入的最常用的流接口?！?strong>這并不是一個函數(shù)式接口。】，獲取流有一下幾種方式

• 所有的Collection集合都可以通過stream默認(rèn)方法獲取流
• Stream接口的靜態(tài)方法of可以獲取數(shù)組對應(yīng)的流

1.根據(jù)Collection獲取流

java.util.Collection 接口中加入了默認(rèn)方法default stream 用來獲取流，所以其所有實(shí)現(xiàn)類均可獲取流

List<String> list = new ArrayList<>();
Stream<String> st1 = list.stream();

Set<String> set = new HashSet<>();
Stream<String> st2 = set.stream();

Vector<String> vector = new Vector<>();
Stream<String> st3 = vector.stream();

2.根據(jù)Map獲取流

java.util.Map 接口不是 Collection 的子接口，且其K-V數(shù)據(jù)結(jié)構(gòu)不符合流元素的單一特征，所以獲取對應(yīng)的流需要分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();

3.根據(jù)數(shù)組獲取流

如果使用的不是集合或映射而是數(shù)組，由于數(shù)組對象不可能添加默認(rèn)方法，所以 Stream 接口中提供了靜態(tài)方法of ，使用很簡單
of方法的簽名是可變長參數(shù)

String[] array = {"張三","李四","王二","麻子"};
Stream<String> st1 = Stream.of(array);

二、常用方法

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

• 延遲方法：返回值任然是Stream接口自身類型的方法，因此支持鏈?zhǔn)秸{(diào)用(除了終結(jié)方法外，其他都是方法均為延遲方法)
• 終結(jié)方法：返回值類型不再是Stream接口自身類型的方法，因此不再支持類似StringBuilder【add的鏈?zhǔn)秸{(diào)用】那樣的鏈?zhǔn)秸{(diào)用，這里介紹count和forEach方法其他終結(jié)方法請參考API

1.逐一處理:forEach

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

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

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

基本使用：

Stream<String> st1 = Stream.of("張三","李四","王二","麻子");
st1.forEach(System.out::println);
// 等同于如下代碼
// st1.forEach(s -> System.out.println(s));

2.過濾:filter

可以通過filter方法將一個流轉(zhuǎn)換成另一個子集流。方法簽名

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

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

java.util.stream.Predicate 函數(shù)式接口唯一的抽象方法為boolean test(T t);,該方法將會產(chǎn)生一個boolean值結(jié)果，代表指定的條件是否滿足。如果結(jié)果為true，那么Stream流的 filter 方法將會留用元素；如果結(jié)果為false，那么 filter 方法將會舍棄元素。

基本使用：

Stream.of("張三","李四","王二","麻子","張三豐","張無忌")
        .filter(s -> s.startsWith("張"))
        .forEach(System.out::println);

3.映射:map

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

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

該接口需要一個Function函數(shù)式接口，可以將當(dāng)前流中的T類型數(shù)據(jù)轉(zhuǎn)換為另一種R類型的流

此前我們已經(jīng)學(xué)習(xí)過 java.util.stream.Function 函數(shù)式接口，其中唯一的抽象方法為：R apply(T t);,這可以將一種T類型轉(zhuǎn)換成為R類型，而這種轉(zhuǎn)換的動作，就稱為“映射”。

Stream.of("1","2","3","4","5","6")
        .map(Integer::parseInt)
        .forEach(s -> System.out.println(s*10));

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

4.統(tǒng)計(jì)個數(shù):count

正如舊集合Collection當(dāng)中的size方法一樣，流提供count方法來數(shù)一數(shù)其中的元素個數(shù)：

long count();

該方法返回一個long值代表元素個數(shù)（不再像舊集合那樣是int值）?；臼褂茫?/p>

System.out.println(Stream.of("1", "2", "3", "4", "5", "6")
        .map(Integer::parseInt)
        .count());

5.取前幾個:limit

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

Stream<T> limit(long maxSize);

參數(shù)是一個long型，如果集合當(dāng)前長度大于參數(shù)則進(jìn)行截?。环駝t不進(jìn)行操作。基本使用

Stream.of("1", "2", "3", "4", "5", "6")
        .limit(1)
        .forEach(System.out::println);

6.跳過前幾個:skip

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

Stream<T> skip(long n);

如果流的當(dāng)前長度大于n,則跳過前n個；否則將會得到一個長度為0的空流。

Stream.of("1", "2", "3", "4", "5", "6")
        .skip(5)
        .forEach(System.out::println);

7.組合:cocat

如果有兩個流，希望合并成為一個流，那么可以使用Stream接口的靜態(tài)方法concat

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

這是一個靜態(tài)方法，與java.lang.String當(dāng)中的concat方法是不同的。

Stream.concat(
        Stream.of("1", "2", "3", "4", "5", "6"),
        Stream.of("7")
).forEach(System.out::println);

8.驗(yàn)證流的工作方式

流的工作方式為：先建立流水線[Lambda表達(dá)式的延遲執(zhí)行]，然后通過內(nèi)部迭代迭代一個走一個，。。。

ArrayList<String> arr = new ArrayList<>();
arr.add("張翠山");
arr.add("張無忌");
arr.add("張大俠");
arr.add("張三豐");
arr.add("張傻屌");

arr.stream().filter(s -> {
    System.out.println("@1");
    return s.startsWith("張");
}).filter(s -> {
    System.out.println("#2");
    return s.length() == 3;
}).forEach(System.out::println);

運(yùn)行結(jié)果

@1
#2
張翠山
@1
#2
張無忌
@1
#2
張大俠
@1
#2
張三豐
@1
#2
張傻屌

9.并發(fā)流的兩種獲取方式

并發(fā)流就是把多擴(kuò)展幾個流水線，將數(shù)據(jù)成幾段交給這些流水線執(zhí)行。每個流水線拿到上每次只有一個數(shù)據(jù)在跑。

并發(fā)流的兩種獲取方式：

Collection<String> coll = new ArrayList<>();

Stream<String> parallelStream1 = coll.parallelStream();
Stream<Integer> parallelStram2 = Stream.of(100,200,300,400,500).parallel();

單線程流和并發(fā)流的案例

        int n = 100000000;
        Integer[] arr = new Integer[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }

        ArrayList<Integer> first = new ArrayList<>();
        ArrayList<Integer> second = new ArrayList<>();

        long start1 = System.currentTimeMillis();
        Stream.of(arr)
                .filter(a -> a % 2 == 0)
                .filter(b -> b % 3 == 0)
                .filter(c -> c % 5 == 0)
                .filter(d -> d % 7 == 0)
                .forEach(first::add);
        long end1 = System.currentTimeMillis();
        System.out.println("單線程流：" + (end1 - start1) + "ms");

        long start2 = System.currentTimeMillis();
        Stream.of(arr).parallel()
                .filter(a -> a % 2 == 0)
                .filter(b -> b % 3 == 0)
                .filter(c -> c % 5 == 0)
                .filter(d -> d % 7 == 0)
                .forEach(second::add);
        long end2 = System.currentTimeMillis();
        System.out.println("并發(fā)流耗時：" + (end2 - start2) + "ms");

執(zhí)行結(jié)果

單線程流：1890ms
并發(fā)流耗時：828ms

三、綜合應(yīng)用

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

import java.util.*;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {

        List<String> one = new ArrayList<>();

        one.add("迪麗熱巴");
        one.add("宋遠(yuǎn)橋");
        one.add("蘇星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("莊子");
        one.add("洪七公");

        List<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("張無忌");
        two.add("趙麗穎");
        two.add("張三豐");
        two.add("尼古拉斯趙四");
        two.add("張?zhí)鞇?);
        two.add("張二狗");
        Stream.concat(
                one.stream().filter(s -> s.length() == 3).limit(3),
                two.stream().filter(s -> s.startsWith("張")).skip(2)
        ).map(Person::new).forEach(System.out::println);

    }
}

class Person{
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                '}';
    }
}