2. 程式人生 > 其它 >Java：stream流

Java：stream流

阿新 • • 發佈：2022-03-02

第一章 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），這點此前已經結合內部類進行
了對比說明。現在，我們仔細體會一下上例程式碼，可以發現：

  1. for迴圈的語法就是“怎麼做”
  2. for迴圈的迴圈體才是“做什麼”
    為什麼使用迴圈？因為要進行遍歷。但迴圈是遍歷的唯一方式嗎？遍歷是指每一個元素逐一進行處理，而並不是從
    第一個到最後一個順次處理的迴圈。前者是目的，後者是方式。
    試想一下，如果希望對集合中的元素進行篩選過濾：
  3. 將集合A根據條件一過濾為子集B；
  4. 然後再根據條件二過濾為子集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流的固有印象！
整體來看，流式思想類似於工廠車間的“生產流水線”。
當需要對多個元素進行操作（特別是多步操作）的時候，考慮到效能及便利性，我們應該首先拼好一個“模型”步驟
方案，然後再按照方案去執行它。

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

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

  • 元素是特定型別的物件，形成一個佇列。 Java中的Stream並不會儲存元素，而是按需計算。
  • 資料來源 流的來源。 可以是集合，陣列 等。
    和以前的Collection操作不同， Stream操作還有兩個基礎的特徵：
  1. Pipelining: 中間操作都會返回流物件本身。 這樣多個操作可以串聯成一個管道， 如同流式風格（fluentstyle）。 這樣做可以對操作進行優化， 比如延遲執行(laziness)和短路( short-circuiting)。
  2. 內部迭代： 以前對集合遍歷都是通過Iterator或者增強for的方式, 顯式的在集合外部進行迭代， 這叫做外部迭代。 Stream提供了內部迭代的方式，流可以直接呼叫遍歷方法。

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

1.3 獲取流

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

  1. 所有的 Collection 集合都可以通過 stream 預設方法獲取流；
  2. 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。這些方法可以被分成兩種：

  1. 延遲方法：返回值型別仍然是 Stream 介面自身型別的方法，因此支援鏈式呼叫。（除了終結方法外，其餘方
    法均為延遲方法。）
  2. 終結方法：返回值型別不再是 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);
}
}

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

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

  1. 第一個隊伍只要名字為3個字的成員姓名；儲存到一個新集合中。
  2. 第一個隊伍篩選之後只要前3個人；儲存到一個新集合中。
  3. 第二個隊伍只要姓張的成員姓名；儲存到一個新集合中。
  4. 第二個隊伍篩選之後不要前2個人；儲存到一個新集合中。
  5. 將兩個隊伍合併為一個隊伍；儲存到一個新集合中。
  6. 根據姓名建立 Person 物件；儲存到一個新集合中。
  7. 列印整個隊伍的Person物件資訊。
    兩個隊伍（集合）的程式碼如下：
//第一支隊伍
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("張二狗");

答案

參考來自黑馬，侵刪

相關推薦

Java：stream流

第一章 Stream流 說到Stream便容易想到I/O Stream，而實際上，誰規定“流”就一定是“IO流”呢？在Java 8中，得益於Lambda所帶

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

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

Java的stream流相關方法

allMatch(Predicate<? super T> predicate) //通過實現predicate介面來對stream流中的所有元素進行自定義匹配，當所有匹配成功時，返回true

淺析PageHelper踩坑：stream流導致分頁失效的問題

　　今天發現使用 PageHelper 進行分頁時，分頁失效了。查了下發現是這個原因，改了之後就正常了，記錄一下。程式碼就不貼了，貼別人的。

【Java】Stream流使用例子

package LearnJava22; import java.util.ArrayList; import java.util.stream.Stream; public class StearmTest {

【Java】Stream流的收集操作

package LearnJava22; import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream;

Java Stream函式語言程式設計第三篇：管道流結果處理

一、Java Stream管道資料處理操作 在本號之前寫過的文章中，曾經給大家介紹過 Java Stream管道流是用於簡化集合類元素處理的java API。在使用的過程中分為三個階段。在開始本文之前，我覺得仍然需要給一些新朋友介紹

Java SE基礎鞏固（十六）：Stream（流）

1 什麼是Stream（流） 電腦科學中有很多帶“流”的概念，例如字元流，位元組流，位元流等等，很少有書籍在講到這些概念的時候會詳解介紹什麼是流，所以有時候會導致讀者感到迷惑，在這裡，我大膽嘗試簡單解釋一下“流

一文了解：JDK8的Stream流操作以及lambda表示式

Lambda Jdk8 Lambda 是一個匿名函式，只關注引數列表和方法體,我們可以把 Lambda表示式理解為是一段可以傳遞的程式碼（將程式碼像資料一樣進行傳遞)

通過例項瞭解Java 8建立Stream流的5種方法

這篇文章主要介紹了通過例項瞭解Java 8建立Stream流的5種方法,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java Stream 流的使用過程解析

1. 篩選和切片 用謂詞篩選 filter方法接受一個返回boolean的方法。 List<Dish> vegetarianMenu=menu.stream().filter(Dish::isVegetarian) .collect(toList());

Java Stream 流實現合併操作示例

本文例項講述了Java Stream 流實現合併操作。分享給大家供大家參考，具體如下：

Java Stream流知識總結

說明 在Java 8中，得益於Lambda所帶來的函數語言程式設計，引入了一個全新的Stream概念，用於解決已有集合類庫既有的弊端

恕我直言你可能真的不會java第5篇：Stream的狀態與並行操作

一、回顧Stream管道流操作 通過前面章節的學習，我們應該明白了Stream管道流的基本操作。我們來回顧一下：

恕我直言你可能真的不會java第6篇：Stream效能差？不要人云亦云

一、粉絲的反饋 問：stream比for迴圈慢5倍，用這個是為了啥？ 答：網際網路是一個新聞氾濫的時代，三人成虎，以假亂真的事情時候發生。作為一個技術開發者，要自己去動手去做，不要人云亦云。

深度分析：java8的新特性lambda和stream流，看完你學會了嗎？

1. lambda表示式 1.1 什麼是lambda 以java為例，可以對一個java變數賦一個值，比如int a = 1，而對於一個方法，一塊程式碼也是賦予給一個變數的，對於這塊程式碼，或者說被賦給變數的函式，就是一個lambda表示式

詳解JAVA Stream流

摘要 Stream 是對集合物件功能的增強，它專注於對集合物件進行各種非常便利、高效的聚合操作，或者大批量資料操作。通常我們需要多行程式碼才能完成的操作，藉助於Stream流式處理可以很簡單的實現。

樂位元組Java8核心特性實戰之五：Stream（流）

說起流，我們會想起手機 ，電腦組裝流水線，物流倉庫商品包裝流水線等等。如果把手機 ,電腦,包裹看做最終結果的話,那麼加工商品前的各種零部件就可以看做資料來源，而中間一系列的加工作業操作，就可以看做流的處理

Java IO操作 流(Stream)、檔案(File)

1.寫入檔案內容 File f = new File(\"C:/Users/Administrator/eclipse-workspace/test/src/test/cc.txt\");

JAVA Stream 流式計算的簡單使用

package com.huang.stream; import java.util.Arrays; import java.util.List; /** * Stream 流式計算 * <p>