java中的Stream流

本文轉載自查看原文 2019-06-08 11:14 1282 Stream/ javaSE

java中的Stream流

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

一、引言

傳統集合的多步遍歷代碼

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

循環遍歷的弊端

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

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

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

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

將集合A根據條件一過濾為子集B；

然后再根據條件二過濾為子集C。

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

public class Demo01List {
    public static void main(String[] args) {
        
        List<String> list = new ArrayList<>();
        list.add("張無忌");
        list.add("周芷若");
        list.add("趙敏");
        list.add("張強");
        list.add("張三豐");

        //對list集合中的元素進行過濾,只要以張開頭的元素,存儲到一個新的集合中
        List<String> listA = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("張")) {
                listA.add(s);
            }
        }

        //對listA集合進行過濾,只要姓名長度為3的人,存儲到一個新集合中
        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if (s.length() == 3) {
                listB.add(s);
            }
        }
        
        //遍歷listB集合
        for (String s : listB) {
            System.out.println(s);
        }
    }
}

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

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

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

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

Stream的更優寫法

下面來看一下借助Java8的Stream API,什么才叫優雅：

public class Demo02Stream {
    public static void main(String[] args) {
        //創建一個List集合,存儲姓名
        List<String> list = new ArrayList<>();
        list.add("張無忌");
        list.add("周芷若");
        list.add("趙敏");
        list.add("張強");
        list.add("張三豐");

        //對list集合中的元素進行過濾,只要以張開頭的元素,存儲到一個新的集合中
        //對listA集合進行過濾,只要姓名長度為3的人,存儲到一個新集合中
        //遍歷listB集合
        list.stream()
                .filter(name -> name.startsWith("張"))
                .filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));
    }
}

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

二、流式思想概述

注意：請暫時忘記對傳統IO流的固有印象！
整體來看，流式思想類似於工廠車間的“生產流水線”。

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

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

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

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

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

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

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

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

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

三、獲取流

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

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

根據Collection & Map & Array 獲取流 &

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

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

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

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

/*
    java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（這並不是一個函數式接口。）
    獲取一個流非常簡單，有以下幾種常用的方式：
        - 所有的Collection集合都可以通過stream默認方法獲取流；
            default Stream<E> stream()
        - Stream接口的靜態方法of可以獲取數組對應的流。
            static <T> Stream<T> of(T... values)
            參數是一個可變參數,那么我們就可以傳遞一個數組
 */
public class Demo01GetStream {
    public static void main(String[] args) {
        //把集合轉換為Stream流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

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

        Map<String,String> map = new HashMap<>();
        //獲取鍵,存儲到一個Set集合中
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        //獲取值,存儲到一個Collection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //獲取鍵值對(鍵與值的映射關系 entrySet)
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        //把數組轉換為Stream流
        Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
        //可變參數可以傳遞數組
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);
        String[] arr2 = {"a","bb","ccc"};
        Stream<String> stream8 = Stream.of(arr2);
    }
}

四、常用方法

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

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

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

逐一處理：forEach

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

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

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

基本使用：

public class Demo02Stream_forEach {
    public static void main(String[] args) {
        //獲取一個Stream流
        Stream<String> stream = Stream.of("張三", "李四", "王五", "趙六", "田七");
        stream.forEach(name->System.out.println(name));
    }
}

過濾：filter

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

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

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

基本使用：

/*
    Stream流中的常用方法_filter:用於對Stream流中的數據進行過濾
    Stream<T> filter(Predicate<? super T> predicate);
    filter方法的參數Predicate是一個函數式接口,所以可以傳遞Lambda表達式,對數據進行過濾
    Predicate中的抽象方法:
        boolean test(T t);
 */
public class Demo03Stream_filter {
    public static void main(String[] args) {
        //創建一個Stream流
        Stream<String> stream = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
        //對Stream流中的元素進行過濾,只要姓張的人
        Stream<String> stream2 = stream.filter((String name)->{return name.startsWith("張");});
        //遍歷stream2流
        stream2.forEach(name-> System.out.println(name));

        /*
            Stream流屬於管道流,只能被消費(使用)一次
            第一個Stream流調用完畢方法,數據就會流轉到下一個Stream上
            而這時第一個Stream流已經使用完畢,就會關閉了
            所以第一個Stream流就不能再調用方法了
            IllegalStateException: stream has already been operated upon or closed
         */
        //遍歷stream流
        stream.forEach(name-> System.out.println(name));
    }
}

映射：map

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

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

該接口需要一個 Function 函數式接口參數，可以將當前流中的T類型數據轉換為另一種R類型的流，稱為映射。

基本使用

public class Demo04Stream_map {
    public static void main(String[] args) {
        //獲取一個String類型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法,把字符串類型的整數,轉換(映射)為Integer類型的整數
        Stream<Integer> stream2 = stream.map((String s)->{
            return Integer.parseInt(s);
        });
        //遍歷Stream2流
        stream2.forEach(i-> System.out.println(i));
    }
}

統計個數：count

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

long count();

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

基本使用：

public class Demo05Stream_count {
    public static void main(String[] args) {
        //獲取一個Stream流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);//輸出7
    }

取用前幾個：limit

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

    Stream<T> limit(long maxSize);

基本使用：

public class Demo06Stream_limit {
    public static void main(String[] args) {
        //獲取一個Stream流
        String[] arr = {"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用limit對Stream流中的元素進行截取,只要前3個元素
        Stream<String> stream2 = stream.limit(3);
        //遍歷stream2流
        stream2.forEach(name-> System.out.println(name));
    }
}

跳過前幾個：skip

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

  Stream<T> skip(long n);

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

基本使用：

public class Demo07Stream_skip {
    public static void main(String[] args) {
        //獲取一個Stream流
        String[] arr = {"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳過前3個元素
        Stream<String> stream2 = stream.skip(3);
        //遍歷stream2流
        stream2.forEach(name-> System.out.println(name));
    }
}
// 灰太狼
// 紅太狼

組合：concat

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

    public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);

        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }

基本使用：

public class Demo08Stream_concat {
    public static void main(String[] args) {
        //創建一個Stream流
        Stream<String> stream1 = Stream.of("張三豐", "張翠山", "趙敏", "周芷若", "張無忌");
        //獲取一個Stream流
        String[] arr = {"美羊羊","喜洋洋","懶洋洋","灰太狼","紅太狼"};
        Stream<String> stream2 = Stream.of(arr);
        //把以上兩個流組合為一個流
        Stream<String> concat = Stream.concat(stream1, stream2);
        //遍歷concat流
        concat.forEach(name-> System.out.println(name));
    }
}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 深入理解 Java中的流 (Stream) java stream流計算 Java8 Stream流 Java Stream流之求和【重學Java】Stream流 Java的Stream流中的常用方法forEach，Arrays.stream(xxx).forEach java8之Stream流處理 java Stream流，方法引用 Java 8 stream 流拆分list Java8 Stream流方法