萬字詳解 | Java 流式編程

来源:https://www.cnblogs.com/xiao2shiqi/archive/2023/04/06/17294514.html
-Advertisement-
Play Games

概述 Stream API 是 Java 中引入的一種新的數據處理方法。它提供了一種高效且易於使用的方法來處理數據集合。Stream API 支持函數式編程，可以讓我們以簡潔、優雅的方式進行數據操作，還有使用 Stream 的兩大原因： 在大多數情況下，將對象存儲在集合中就是為了處理它們，因此你會發 ...


概述

Stream API 是 Java 中引入的一種新的數據處理方法。它提供了一種高效且易於使用的方法來處理數據集合。Stream API 支持函數式編程，可以讓我們以簡潔、優雅的方式進行數據操作，還有使用 Stream 的兩大原因：

  1. 在大多數情況下，將對象存儲在集合中就是為了處理它們，因此你會發現你把編程 的主要焦點從集合轉移到了流上。
  2. 當 Lambda 表達式和方法引用（method references），流（Stream）結合使用的時候會讓人感覺自成一體，行雲流水的感覺

先展示一段簡單的流式編程：

import java.util.Random;

public class Randoms {
    
    public static void main(String[] args) {
        // 隨機展示 5 至 20 之間不重覆的整數併進行排序
        new Random(47)
                .ints(5, 20)
                .distinct()             // 使流中的整數不重覆
                .limit(7)       		// 獲取前 7 個元素
                .sorted()               // 排序
                .forEach(System.out::println);
    }
}

輸出結果：

6
10
13
16
17
18
19

實際上函數式的編程風格是聲明式（Declarative programming）的，它聲明瞭要做什麼， 而不是指明（每一步）如何做。

相同的程式，相比聲明式風格，命令式（Imperative）編程的形式（指明每一步如何做），代碼閱讀起來會更難理解：

import java.util.Random;
import java.util.SortedSet;
import java.util.TreeSet;

public class ImperativeRandoms {

    public static void main(String[] args) {
        Random rand = new Random(47);
        SortedSet<Integer> rints = new TreeSet<>();
        while (rints.size() < 7) {
            int r = rand.nextInt(20);
            if (r < 5) continue;
            rints.add(r);
        }
        System.out.println(rints);
    }
}

輸出結果：

[7, 8, 9, 11, 13, 15, 18]

所以使用流式編程的幾個理由：

  1. 表達力強，清晰的語義
  2. 內部迭代 internal iteration （看不見迭代過程）更簡單的處理併發
  3. 流式懶載入的，只在絕對必要時才計算

Java 8 通過在添加介面中添加 default 關鍵字，通過預設方法的方式將流式 Stream 方法平滑地嵌入到現有的類中，

流操作的類型有三種：

  1. 創建流：生產流
  2. 修改流元素：中間操作
  3. 消費流元素：終端操作，收集流元素，通常式匯入一個集合

創建流

通過 Stream.of() 很容見的將一組元素轉化為流：

import java.util.stream.Stream;

public class StreamOf {

    public static void main(String[] args) {
        // 創建流
        Stream.of(new Bubble(1), new Bubble(2), new Bubble(3))
                .forEach(System.out::println);

        Stream.of("It's ", "a ", "wonderful ", "day ", "for ", "pie!")
                .forEach(System.out::print);

        System.out.println();
        Stream.of(3.14159, 2.718, 1.618)
                .forEach(System.out::println);
    }
}

輸出結果：

Bubble 1
Bubble 2
Bubble 3
It's a wonderful day for pie!
3.14159
2.718
1.618

通過 stream() 方法很容易將傳統的集合轉化為 Stream：

public class CollectionToStream {

    public static void main(String[] args) {
        List<Bubble> bubbles = Arrays.asList(new Bubble(1), new Bubble(2), new Bubble(3));

        System.out.println(bubbles.stream()  // 將集合轉換成為流
                .mapToInt(b -> b.i)          // 獲取流中所有元素，對元素進行應用操作，並產生新的對象，這裡的 mapToInt 中間操作會轉換成為包含整型數字的 IntStream
                .sum());                     // 合計

        HashSet<String> w = new HashSet<>(Arrays.asList("It's a wonderful day for pie!".split(" ")));
        w.stream()
                .map(x -> x + " ")
                .forEach(System.out::print);        // stream 遍歷並且列印 Set 中的元素
        System.out.println();

        Map<String, Double> m = new HashMap<>();
        m.put("pi", 3.14159);
        m.put("e", 2.718);
        m.put("phi", 1.618);
        m.entrySet().stream()
                .map(e -> e.getKey() + ": " + e.getValue())
                .forEach(System.out::println);      // stream 遍歷並且列印 Map 中的元素
    }
}

輸出結果：

6
a pie! It's for wonderful day 
phi: 1.618
e: 2.718
pi: 3.14159

隨機數流

Java 8 的 Random 類也集成流的方法，很方便的創建隨機數流：

import java.util.Random;
import java.util.stream.Stream;

// 生成隨機數流
public class RandomGenerators {

    public static <T> void show(Stream<T> stream) {
        stream.limit(4).forEach(System.out::println);
        System.out.println("++++++++++");
    }

    public static void main(String[] args) {
        Random rand = new Random(47);
        show(rand.ints().boxed());
        show(rand.longs().boxed());
        show(rand.doubles().boxed());
        // 控制上限和下限
        show(rand.ints(10, 20).boxed());
        show(rand.longs(50, 100).boxed());
        show(rand.doubles(20, 30).boxed());
        // 控制流大小
        show(rand.ints(2).boxed());
        show(rand.longs(2).boxed());
        show(rand.doubles(2).boxed());
        // 控制流大小和上限和下限
        show(rand.ints(3, 3, 9).boxed());
        show(rand.longs(3, 12, 22).boxed());
        show(rand.doubles(3, 11.5, 12.3).boxed());
    }
}

輸出結果：

-1172028779
1717241110
-2014573909
229403722
++++++++++
2955289354441303771
3476817843704654257
-8917117694134521474
4941259272818818752
++++++++++
# ……………………

int 整型範圍

Stream API 對基本數據類型生成流提供便捷的方法，例如對一段整型序列求和，展示新舊代碼對比

import java.util.stream.IntStream;

public class Ranges {

    public static void main(String[] args) {
        // 傳統方法
        int result = 0;
        for (int i = 0; i < 20; i++) {
            result += i;
        }
        System.out.println(result);

        // 使用流
        System.out.println(IntStream.range(0, 20).sum());
    }
}

輸出結果：

190
190

generate()

Stream API 還可以結合 Supplier 函數介面來創建流，例如，創建一個隨機數序列：

import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamGenerateExample {

    public static void main(String[] args) {
        Random random = new Random();
        Stream<Integer> randomNumbers = Stream.generate(random::nextInt);

        // 生成 10 個隨機數放入集合中
        List<Integer> integers = randomNumbers
                .limit(10)
                .collect(Collectors.toList());

        integers.forEach(System.out::println);
    }
}

輸出結果：

514000574
1771591868
600289224
-1474939200
-276604430
-876159270
509964750
-497958443
811408347
703285366

iterate()

Stream.iterate 是 Java 8 引入的 Stream API 的一部分，它接受一個種子值（seed）和一個一元函數（unary operator），然後生成一個無限的、順序的流。流中的每個元素都是通過對前一個元素應用一元函數生成的。與 Stream.generate 類似， Stream.iterate 常常用於生成一個斐波那契數列，代碼示例：

import java.util.stream.Stream;

public class Fibonacci {
    int x = 1;

    Stream<Integer> numbers() {
        return Stream.iterate(0, i -> {
            int result = x + i;
            x = i;
            return result;
        });
    }

    public static void main(String[] args) {
        Fibonacci fbi = new Fibonacci();
        fbi.numbers()
                .skip(20)           // 丟棄前 20 個
                .limit(10)     // 取 10 個
                .forEach(System.out::println);
    }
}

輸出結果：

6765
10946
17711
28657
46368
75025
121393
196418
317811
514229

Stream.iterate 和 Stream.generate 都是 Java 8 引入的 Stream API 的一部分，它們用於生成無限的順序流。稍不留神就容易把它們搞混，可以通過以下的方式來區分它們：

iterate：

  • 它接受一個種子值（seed）和一個一元函數（unary operator）。
  • 它生成的流中的每個元素都是通過對前一個元素應用一元函數生成的。
  • 適用於需要生成基於前一個值的序列的場景，例如生成遞增/遞減序列、斐波那契數列等。

generate：

  • 它接受一個 Supplier<T> 類型的參數。
  • 它生成的流中的每個元素都是由提供的 Supplier 生成的。
  • 適用於生成獨立於前一個值的序列的場景，例如生成隨機數序列、常量序列等。

Arrays

Arrays 類中的 stream() 方法用於將數組轉換為 Stream。以下是使用 Arrays.stream() 方法的一些示例：

import java.util.Arrays;

public class ArraysStreamExample {

    public static void main(String[] args) {
        // IntStream
        int[] integer = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        Arrays.stream(integer)
                .filter(n -> n % 2 == 0)
                .forEach(System.out::println);

        // Stream<String>
        String[] words = {"hello", "world", "java", "stream"};
        Arrays.stream(words)
                .map(String::toUpperCase)
                .forEach(System.out::println);

        // DoubleStream
        double[] doubles = {1.0, 3.5, 7.2, 8.8, 12.0, 15.5};
        double average = Arrays.stream(doubles)
                .average()
                .orElse(0.0);
        System.out.println("Average: " + average);
    }
}

輸出結果：

2
4
6
8
10
HELLO
WORLD
JAVA
STREAM
Average: 8.0

中間操作

中間操作（intermediate operations）是那些在 Stream 上執行的操作，但不會觸發流的處理。它們通常返回一個新的 Stream，該 Stream 包含應用了某種操作後的元素。

以下是一些常見的中間操作：

  1. filter(Predicate<T> predicate)：根據給定的謂詞篩選 Stream 中的元素。
  2. map(Function<T, R> mapper)：將 Stream 中的每個元素轉換為另一種類型，根據給定的映射函數。
  3. flatMap(Function<T, Stream<R>> mapper)：將每個元素轉換為另一個 Stream，然後將所有這些流連接成一個 Stream。
  4. distinct()：返回一個去重後的 Stream，其中每個元素只出現一次。
  5. sorted()：返回一個按自然順序排序的 Stream。
  6. sorted(Comparator<T> comparator)：根據給定的比較器返回一個排序後的 Stream。
  7. peek(Consumer<T> action)：對 Stream 中的每個元素執行給定的操作，但不會改變 Stream 中的元素。通常用於調試目的。

註意：中間操作是惰性的，也就是說，它們只在終端操作被調用時才會實際執行。例如 forEach、collect、reduce 等

跟蹤和調試

Stream.peek() 是一個中間操作，它接受一個 Consumer，並允許您在流的每個元素上執行某個操作，同時保持流的元素不變。通常用於調試目的，因為它允許您查看流處理過程中的中間結果。示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Peeking {

    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Cindy", "David");

        List<String> result = names.stream()
                .filter(name -> name.length() > 3)
                .peek(name -> System.out.println("Filtered name: " + name))
                .map(String::toUpperCase)
                .peek(name -> System.out.println("Mapped name: " + name))
                .collect(Collectors.toList());

        System.out.println("Result: " + result);
    }
}

以上代碼邏輯是：

  1. 首先通過 filter 操作篩選出長度大於3的名字
  2. 然後，我們使用 peek() 來列印篩選後的名字
  3. 接下來，我們使用 map 操作將篩選後的名字轉換為大寫形式
  4. 然後我們再次使用 peek() 來列印轉換後的名字
  5. 最後，我們通過 collect 操作將流中的元素收集到一個新的 List 中，並列印結果

輸出結果：

Filtered name: John
Mapped name: JOHN
Filtered name: Alice
Mapped name: ALICE
Filtered name: Cindy
Mapped name: CINDY
Filtered name: David
Mapped name: DAVID
Result: [JOHN, ALICE, CINDY, DAVID]

排序

Stream.sorted() 可以通過內置的比較器，很容易的對集合進行排序

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class Peeking {

    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Cindy", "David");

        List<String> result = names.stream()
                .sorted(Comparator.reverseOrder())
                .map(String::toLowerCase)
                .collect(Collectors.toList());

        System.out.println("Result: " + result);
    }
}

輸出結果：

Result: [john, david, cindy, bob, alice]

過濾元素

常見的場景，Stream API 提供以下函數進行過濾：

  • distinct()：消除流中重覆的元素，相比創建 Set 成本低的多
  • filter(Predicate)：根據 Predicate 邏輯進行過濾，剩下的元素傳遞給後面的流

簡單看一個示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class DistinctAndFilterExample {

    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 1, 4, 5, 4, 6, 7, 7, 8);
        List<Integer> result = numbers.stream()
                .distinct()     // 1: 消除重覆元素
                .filter(e -> e % 2 == 0)        //2: 篩選出偶數
                .collect(Collectors.toList());      //3: 將結果放入 List 中

        System.out.println(result);
    }
}

以上代碼邏輯很簡單：

  1. 使用 distinct() 方法刪除重覆元素
  2. 使用 filter() 方法篩選出偶數
  3. 我們通過 collect() 方法將處理後的 Stream 轉換回 List

輸出結果：

[2, 4, 6, 8]

操作元素

對元素的操作主要通過 map(Function) 來完成，在上面的示例代碼中也有看到過，常見於以下場景：

  1. 類型轉換
  2. 數據轉換
  3. 對象屬性提取

類似函數 mapToInt，mapToLong，mapToDouble 操作都一樣，只是結果分別為：IntStream，LongStream，DoubleStream

以下是一個簡單的使用示例：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MapExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Using map(Function) to square each number
        List<Integer> squaredNumbers = numbers.stream()
                                              .map(number -> number * number)
                                              .collect(Collectors.toList());

        System.out.println("Original list: " + numbers);
        System.out.println("Squared numbers: " + squaredNumbers);
    }
}

輸出結果：

Original list: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]

合併流

某些情況，我們輸入源的流可能是一個複雜的多層嵌套的數據結構，我們想在處理流數據的同時，順便也更更改它的結構，例如把它展開為一個展平為單層數據結構，那麼 flatMap() 中間函數就會派上用場：

  • flatMap()：與 map() 所作的事情相同，但它將這些生成的 Stream 合併為一個單一的 Stream
有啥用 ?

flatMap() 在函數式編程和流式處理中非常有用，因為它可以解決一些常見的數據處理問題。

  1. 展平嵌套數據結構：在處理複雜的數據結構時，我們經常會遇到嵌套的集合，例如列表的列表、集合的集合等。flatMap() 可以將這些嵌套的數據結構展平為一個單一的流，從而簡化後續的數據處理和操作。
  2. 合併多個流：在某些情況下，我們需要將多個流合併成一個流，以便對所有流中的數據執行相同的操作。flatMap() 可以幫助我們將這些流合併為一個流，從而提高代碼的可讀性和可維護性。
  3. 動態生成流：flatMap() 使我們能夠根據流中的每個元素動態生成新的流，並將這些新生成的流合併為一個流。這對於根據流中的數據動態創建數據處理管道非常有用。
  4. 更高效的操作鏈：在某些情況下，使用 flatMap() 可以減少對流中數據的遍歷次數，從而提高操作鏈的效率。例如，如果我們需要先對流中的每個元素執行映射操作，然後再執行篩選操作，我們可以使用 flatMap() 將這兩個操作組合在一起，從而減少對流的遍歷次數。

展平嵌套數據結構：例如，將一個列表的列表轉換為一個包含所有元素的平面列表：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FlatMapExample {

    public static void main(String[] args) {
        List<List<Integer>> nestedList = Arrays.asList(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5, 6),
                Arrays.asList(7, 8, 9)
        );

        List<Integer> flatList = nestedList.stream()
                .flatMap(list -> list.stream())
                .collect(Collectors.toList());

        System.out.println("Nested list: " + nestedList);
        System.out.println("Flat list: " + flatList);
    }
}

輸出結果：

Nested list: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Flat list: [1, 2, 3, 4, 5, 6, 7, 8, 9]

合併多個流：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FlatMapExample {

    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("a", "b", "c");
        List<String> list2 = Arrays.asList("d", "e", "f");
        List<String> list3 = Arrays.asList("g", "h", "i");

        // 創建包含多個列表的流
        Stream<List<String>> listsStream = Stream.of(list1, list2, list3);

        // 使用 flatMap() 合併多個流
        List<String> mergedList = listsStream.flatMap(list -> list.stream())
                .collect(Collectors.toList());

        System.out.println("Merged list: " + mergedList);
    }
}

說明以下上面的示例的代碼：

  1. 首先創建了一個包含三個列表的流（listsStream）
  2. 使用 flatMap() 方法將這些列表轉換為單獨的流，並將這些流合併為一個流
  3. 最後，我們使用 collect() 方法將合併後的流轉換為一個列表（mergedList）

通過使用 flatMap()，我們可以輕鬆地將多個流合併為一個流，從而簡化數據處理和操作，輸出結果：

Merged list: [a, b, c, d, e, f, g, h, i]
和 map() 區別
  • map() 主要用於轉換流中的元素，但保持流的結構不變。
  • flatMap() 和 flatMap(Function) 主要用於將嵌套或多層數據結構展平為單層數據結構。
如何選擇 ?
  • 如果你只需要對流中的元素執行某種操作或計算，而不需要改變流的結構，那麼 map() 是一個很好的選擇
  • 如果你需要將多個 Stream 合併為一個 Stream，或者將嵌套數據結構展平為單層數據結構，那麼 flatMap() 是一個更合適的選擇

Optional 類

Optional 主要用於在流中處理一些空元素，但是它還可以應用在代碼的其他地方，它帶來以下一些好處，例如：

  • 避免 NullPointerException：Optional 類幫助您更優雅地處理可能為 null 的值
  • 提高代碼可讀性：使用 Optional 類可以讓您的代碼更具表現力，更容易理解
  • 更好的 API 設計：使用 Optional 類可以讓您的 API 更清晰地表達預期行為，例如，返回值可能為空的情況。

流裡面的 Optional

在使用 Stream 時，很多操作都會返回 Optional 對象，例如：

  • findFirst(): 返回 Stream 中的第一個對象，使用 Optional 包裝
  • findAny(): 返回 Stream 中任意一個對象，使用 Optional 包裝
  • max(): 返回 Stream 中最大的對象，使用 Optional 包裝
  • min(): 返回 Stream 中最小的對象，使用 Optional 包裝
  • average(): 返回 Stream 中所有對象的平均值，使用 OptionalDouble 包裝

示例代碼：

import java.util.*;

public class OptionalExample {

    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        Optional<Integer> firstNumber = numbers.stream().filter(n -> n % 2 == 0).findFirst();
        System.out.println("findFirst() example: " + firstNumber.orElse(-1));   // 輸出：2

        Optional<Integer> anyNumber = numbers.stream().filter(n -> n > 2).findAny();
        System.out.println("findAny() example: " + anyNumber.orElse(-1));   // 輸出：3

        Optional<Integer> maxNumber = numbers.stream().max(Comparator.naturalOrder());
        System.out.println("max() example: " + maxNumber.orElse(-1)); // 輸出：9

        Optional<Integer> minNumber = numbers.stream().min(Comparator.naturalOrder());
        System.out.println("min() example: " + minNumber.orElse(-1)); // 輸出：1

        OptionalDouble average = numbers.stream().mapToInt(Integer::intValue).average();
        System.out.println("average() example: " + (average.isPresent() ? average.getAsDouble() : -1)); // 輸出：5.0
    }
}

輸出結果：

findFirst() example: 2
findAny() example: 3
max() example: 9
min() example: 1
average() example: 5.0

示例代碼還展示一些解包 Optional 的操作：

  • ifPresent(Consumer)：當值存在時調用 Consumer，否則什麼也不做
  • orElse(otherObject)：如果值存在則直接返回，否則生成 otherObject

Optional 還提供更靈活的 Supplier 函數式介面的調用：

  • orElseGet(Supplier)：如果值存在則直接返回，否則使用 Supplier 函數生成一 個可替代對象
  • orElseThrow(Supplier)：如果值存在直接返回，否則使用 Supplier 函數生成一 個異常

可以通過以下示例代碼來理解：

public class OptionalExample {

    public static void main(String[] args) {
        // 生成一個空 Optional
        Optional<String> optionalValue = Optional.empty();

        // orElseGet() 示例
        String value1 = optionalValue.orElseGet(() -> "Default value");
        System.out.println("Value 1: " + value1); // 輸出：Value 1: Default value

        // orElseThrow() 示例
        try {
            String value2 = optionalValue.orElseThrow(
                () -> new IllegalStateException("Value is not present")
            );
            System.out.println("Value 2: " + value2);
        } catch (RuntimeException e) {
            // 輸出：Exception caught: Value is not present
            System.out.println("Exception caught: " + e.getMessage()); 
        }
    }
}

輸出結果：

Value 1: Default value
Exception caught: Value is not present

創建 Optional

我們也可以在自己的代碼裡面創建 Optional 對象，有以下幾個靜態方法可以使用：

  • Optional.empty()：創建一個空的 Optional 對象。這個對象不包含任何值
  • Optional.of()：使用一個非空值創建一個 Optional 對象。如果傳入的值為 null，將拋出一個空指針異常
  • Optional.ofNullable()：創建一個可能為 null 的 Optional 對象

示例代碼：

import java.util.*;

public class OptionalExample {
    
    public static void main(String[] args) {
        // 生成一個空的 Optional
        Optional<String> emptyOptional = Optional.empty();
        // 生成一個不為空的 Optional
        Optional<String> optionalWithValue = Optional.of("hello world");
        // 可能為空的 Optional
        Optional<String> optionalWithValue1 = Optional.ofNullable("hello world"); // 非空值
        Optional<String> optionalWithValue2 = Optional.ofNullable(null); // 空值
    }
}

操作 Optional

創建 Optional 對象後，可以通過內置的函數對 Optional 進行更多的操作，常見的有：

  • filter(Predicate): 對象的值滿足給定的 Predicate，則返回該 Optional 對象
  • map(Function): 使用給定的 Function 對該值進行轉換，並返回一個包含轉換後值的新 Optional 對象
  • flatMap(Function): 使用給定的 Function 對該值進行轉換，並返回一個包含轉換後值的新 Optional 對象。

示例代碼：

import java.util.*;

public class OptionalExample {

    public static void main(String[] args) {
        Optional<Integer> optionalValue1 = Optional.of(10);
        Optional<Integer> optionalValue2 = Optional.empty();

        // 使用 filter() 方法
        Optional<Integer> filteredValue1 = optionalValue1.filter(value -> value > 5);
        System.out.println("Filtered value 1: " + filteredValue1.orElse(-1));
        
        // 使用 map() 方法
        Optional<String> mappedValue1 = optionalValue1.map(value -> "Value is: " + value);
        System.out.println("Mapped value 1: " + mappedValue1.orElse("Not present"));
        
        // 使用 flatMap() 方法
        Optional<String> flatMappedValue1 = optionalValue2.flatMap(value -> Optional.of("Value is: " + value));
        System.out.println("FlatMapped value 1: " + flatMappedValue1.orElse("Not present"));
    }
}

輸出結果：

Filtered value 1: 10
Mapped value 1: Value is: 10
FlatMapped value 1: Not present

註意：這裡的 flatMap() 與 map() 方法不同，flatMap() 會改變 Optional 結構本身，map() 則不會

終端操作

終端操作（Terminal Operations）是我們在流管道中所做的最後一件事，通過該操作獲得流中的結果

數組

通過以下方法，可以輕易的收集一個流，並且將流轉為數組：

  • toArray()：轉換為對象數組
  • toArray(generator)：轉換為特定類型的數組

示例代碼：

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamToArrayExample {

    public static void main(String[] args) {
        // 轉換為對象數組
        Stream<String> stringStream1 = Stream.of("apple", "banana", "cherry");
        System.out.println("Stream to array 1: " + Arrays.toString(stringStream1.toArray()));

        // 轉換為特定類型的數組
        Stream<String> stringStream2 = Stream.of("apple", "banana", "cherry");
        String[] stringArray = stringStream2.toArray(String[]::new);
        System.out.println("Stream to array 2: " + Arrays.toString(stringArray));

        // 對於基本類型的數組，可以使用特定的流類
        int[] array = IntStream.range(1, 6).toArray();
        System.out.println("Stream to array 3: " + Arrays.toString(array));
    }
}

輸出結果：

Stream to array 1: [apple, banana, cherry]
Stream to array 2: [apple, banana, cherry]
Stream to array 3: [1, 2, 3, 4, 5]

迴圈

Stream 中提供 2 個迴圈遍歷方法，用於消費流，分別如下：

  • forEach()：遍歷流，在並行流中不保證流的順序
  • forEachOrdered()：遍歷流，在並行流中保證按照流中元素的順序執行操作

我們通過以下示例代碼來證明：

import java.util.Arrays;
import java.util.List;

public class ForEachOrderedParallelExample {

    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("apple", "banana", "cherry", "date", "fig", "grape");

        // 順序流
        System.out.println("Sequential stream:");
        stringList.stream().forEachOrdered(System.out::println);

        // 並行流 （亂序）
        System.out.println("\nParallel stream with forEach:");
        stringList.parallelStream().forEach(System.out::println);

        // 並行流 （順序）
        System.out.println("\nParallel stream with forEachOrdered:");
        stringList.parallelStream().forEachOrdered(System.out::println);
    }
}

輸出結果：

Sequential stream:
apple
banana
cherry
date
fig
grape

Parallel stream with forEach:
date
grape
fig
cherry
banana
apple

Parallel stream with forEachOrdered:
apple
banana
cherry
date
fig
grape

集合

主要用於將流中的元素收集到不同類型的結果容器，如集合、字元串或其他數據結構。它的主要方法有：

  • collect(Collector)：使用 Collector 收集流元素到結果集合中

我們看看如何把 Stream 收集為常見的 List，Set，Map，還有 String ，示例代碼：

public class CollectExample {

    public static void main(String[] args) {
        // 收集到 List
        List<String> collectedList = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("Collected List: " + collectedList);

        // 收集到 Set
        Set<String> collectedSet = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toLowerCase)
                .collect(Collectors.toSet());
        System.out.println("Collected Set: " + collectedSet);

        // 收集到 Map
        Map<String, Integer> map = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toUpperCase)
                .collect(Collectors.toMap(s -> s, String::length));
        System.out.println("Collected Map: " + map);

        // 收集到 String，使用逗號分隔
        String joinedString  = Stream.of("apple", "banana", "orange", "grape")
                .map(String::toUpperCase)
                .collect(Collectors.joining(","));
        System.out.println("Joined String: " + joinedString);
    }
}

輸出結果：

Collected List: [APPLE, BANANA, ORANGE, GRAPE]
Collected Set: [banana, orange, apple, grape]
Collected Map: {APPLE=5, GRAPE=5, BANANA=6, ORANGE=6}
Joined String: APPLE,BANANA,ORANGE,GRAPE

說明：在這裡我們只是簡單介紹了幾個 Collectors 的運用示例。

實際上，它還有一些非常複雜的操作實現，可通過查看 java.util.stream.Collectors 的 API 文檔瞭解

組合

用於對流中的元素執行累積操作，將它們減少為一個值。reduce 的使用場景包括對流中的元素執行聚合操作，例如求和、求積、求最大值、求最小值等。Stream 裡面的 reduce 方法有以下幾種形式：

  • reduce(BinaryOperator)：使用給定的累積器函數，對流中的元素進行累積操作。返回一個 Optional<T>
  • reduce(identity, BinaryOperator)： 使用給定的初始值（identity）和累積器函數，對流中的元素進行累積操作。因此如果流為空，identity 就是結果

先看看 reduce 的示例代碼：

import java.util.OptionalInt;
import java.util.stream.IntStream;

public class ReduceExample {

    public static void main(String[] args) {
        // 求和
        OptionalInt sum = IntStream.range(0, 100).reduce(Integer::sum);
        sum.ifPresent(System.out::println);

        // 求積
        OptionalInt numbers = IntStream.range(0, 100).reduce((a, b) -> a * b);
        numbers.ifPresent(System.out::println);

        // 求最大值
        OptionalInt max = IntStream.range(0, 100).reduce(Integer::max);
        max.ifPresent(System.out::println);

        // 求最小值
        OptionalInt min = IntStream.range(0, 100).reduce(Integer::min);
        min.ifPresent(System.out::println);
        
        // 使用給定的初始值（identity）和累積器函數，對流中的元素進行累積操作，這裡返回 int 值
        int reduced = IntStream.range(0, 100).reduce(10, Integer::sum);
        System.out.println(reduced);
    }
}

輸出結果：

4950
0
99
0
4960

還有一種 reduce(identity, BiFunction, BinaryOperator)：更複雜的使用形式暫不介紹。我建議可以顯式地組合 map() 和 reduce() 來更簡單的表達它。

匹配

在 Stream 中的終端操作中，提供 allMatch, anyMatch, 和 noneMatch 它們用於檢查流中的元素是否滿足某個條件：

  • allMatch(Predicate) ：流的每個元素提供給 Predicate 都返回 true ，結果返回為 true
  • anyMatch(Predicate)：流中任意一個元素提供的 Predicate 返回 true，結果返回 true
  • noneMatch(Predicate)：流的每個元素提供的 Predicate 返回 false，結果返回 true

PS：以上計算都是短路操作，在匹配第一個結果時，則停止執行計算

下麵是它們的使用場景和示例：

import java.util.stream.Stream;

public class MatchExample {

    public static void main(String[] args) {
        // allMatch：檢查流中的所有元素是否都滿足某個條件
        boolean allEven = Stream.of(1, 2, 3, 4, 5).allMatch(num -> num % 2 == 0);
        System.out.println(allEven); // 輸出：false

        // anyMatch：檢查流中是否存在滿足某個條件的元素
        boolean anyEven = Stream.of(1, 2, 3, 4, 5).anyMatch(num -> num % 2 == 0);
        System.out.println(anyEven); // 輸出：true

        // noneMatch：檢查流中是否不存在滿足某個條件的元素
        boolean noneMatch = Stream.of(1, 2, 3, 4, 5).noneMatch(num -> num > 10);
        System.out.println(noneMatch);  // 輸出：true
    }
}

輸出結果：

false
true
true

查找

在 Stream 中的終端操作中，可以根據 Predicate 獲取指定的元素（在 Optional 章節介紹過），查找函數如下：

  • findFirst()：查找第一個滿足某個條件的元素，這在有序流中非常有用
  • findAny()：在流中查找任意一個滿足某個條件的元素，這在並行流中非常有用

代碼示例：

import java.util.Optional;
import java.util.stream.Stream;

public class FindExample {

    public static void main(String[] args) {
        // findFirst 示例
        Optional<Integer> first = Stream.of(1, 2, 3, 4, 5).filter(num -> num % 2 == 0).findFirst();
        first.ifPresent(System.out::println); // 輸出：2

        // findAny 示例
        Optional<Integer> any = Stream.of(1, 2, 3, 4, 5, 6).filter(num -> num % 2 == 0).findAny();
        any.ifPresent(System.out::println); // 輸出：2 或者 4 或者 6
    }
}

統計

最後就是一些常見對流進行統計的函數了：

  • count()：統計流中的元素數量
  • max(Comparator)：根據給定的比較器查找流中的最大值
  • min(Comparator)：根據給定的比較器查找流中的最小值

示例代碼：

// count: 流中的元素個數
System.out.println(Stream.of(1, 2, 3, 4, 5).count()); // 輸出：5

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers.stream().max(Comparator.naturalOrder());
Optional<Integer> min = numbers.stream().min(Comparator.naturalOrder());

// max, min: 根據給定的比較器查找流中的最大值或最小值
max.ifPresent(System.out::println); // 輸出：5
min.ifPresent(System.out::println); // 輸出：1

輸出結果：

5
5
1

以下方式是適用於基本數據類型的特殊流，它們提供了對流中數字的基本統計信息：

  • average() ：求取流元素平均值
  • max() 和 min()：數值流操作無需 Comparator
  • sum()：對所有流元素進行求和

代碼示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// average: 求取流元素平均值
numbers.stream().mapToInt(Integer::intValue).average().ifPresent(System.out::println);  // 輸出：3.0
// max: 數值流求最大值
numbers.stream().mapToInt(Integer::intValue).max().orElse(0);  // 輸出：5
// min: 數值流最小值
numbers.stream().mapToInt(Integer::intValue).min().orElse(0);  // 輸出：1
// sum: 數值流求和
numbers.stream().mapToInt(Integer::intValue).sum();  // 輸出：15

上例操作對於 LongStream 和 DoubleStream 同樣適用

總結

函數式編程 對 Java 語言的編程範式產生了深遠的影響。在 Stream API 出現之前，處理集合數據通常需要使用 for 迴圈、條件判斷和輔助變數等。這樣的代碼往往冗長、複雜，不易閱讀和維護。Stream API 的引入，讓我們能以函數式編程的方式處理數據，提高了代碼的簡潔性、可讀性和可維護性。隨著函數式編程在軟體開發領域的普及，Java 可能會引入更多的函數式編程特性，讓我們能夠更方便地使用函數式編程範式編寫代碼。隨著函數式編程在軟體開發領域的普及，Java 可能會引入更多的函數式編程特性，讓我們能夠更方便地使用函數式編程範式編寫代碼。 總之，Java 其未來依然充滿潛力。隨著技術的發展和需求的變化，Java 將不斷演進，為開發者提供更好的編程體驗


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 小程式容器助力企業小程式開放平臺打造
    基於 Node.js、Express.js 和 MongoDB 通過Mongoose驅動進行 REST API 開發的輕量級樣板。集成了Swagger UI、JWT、session、發送郵箱驗證、日誌管理、統一的預定義狀態碼響應格式等，對於為前端平臺構建純凈的Web API非常有用。 ...
  • CSS偽元素詳解以及偽元素與偽類的區別
    前面已經介紹過CSS偽類的知識，具體可見前文 CSS偽類知識詳解。 偽元素常常被誤解為偽類，主要在於他們的語法相似，都是對於選擇器功能的擴展，相似程度很高導致被混淆。 本文通過詳細介紹偽元素和常見的使用方法，最後也會分析下偽元素與偽類的基本區別。 基本描述 CSS偽元素也是應用於選擇器的關鍵字，允許 ...
  • 前端設計模式——MVC模式
    MVC模式（Model-View-Controller）：是一種前端和後端都廣泛應用的設計模式。它將應用程式的業務邏輯、數據表示和用戶界面分離，使得開發人員可以獨立地修改各部分而不影響其他部分。MVC設計模式有助於提高代碼的可讀性、可維護性和可重用性。 MVC是Model-View-Controll ...
  • React的行內樣式與CSS
    如何為組件添加 CSS 的 class？ 傳遞一個字元串作為 className 屬性： render() { return <span className="menu navigation-menu">Menu</span> } CSS 的 class 依賴組件的 props 或 state 的情 ...
  • 【過濾器設計模式詳解】C/Java/JS/Go/Python/TS不同語言實現
    過濾器模式（Filter Pattern）或標準模式（Criteria Pattern），是一種結構型模式。這種模式允許使用不同的標準條件來過濾一組對象，並通過邏輯運算的方式把各條件連接起來，它結合多個標準來獲得單一標準。 例子將創建一個 Person 對象、Criteria 介面和實現了該介面的實... ...
  • 從軟體複雜度的角度去理解DDD
    從我們作為業務開發主要的職責深入到DDD的本質是什麼？複雜度應處理？規範設計怎麼做？本文將全方位為大家解答。 ...
  • 生產事故-記一次特殊的OOM排查
    入職多年，面對生產環境，儘管都是小心翼翼，慎之又慎，還是難免捅出簍子。輕則滿頭大汗，面紅耳赤。重則系統停擺，損失資金。每一個生產事故的背後，都是寶貴的經驗和教訓，都是項目成員的血淚史。為了更好地防範和遏制今後的各類事故，特開此專題，長期更新和記錄大大小小的各類事故。有些是親身經歷，有些是經人耳傳口授 ...
  • 記憶體淘汰策略|頁面置換演算法對比總結
    在學習【操作系統】 【MySQL】【Redis】後，發現其都有一些緩存淘汰的策略，因此一篇小文章總結一下。 目前還沒著筆，初略一想MySQL和操作系統應該都是使用的年輕代和老生代的改進策略，而Redis使用的是隨機抽的策略。 MySQL MySQL中存在一個記憶體緩存池，Buffer Pool。裡面存 ...
一周排行
    -Advertisement-
    Play Games
  • C# + WPF 音頻播放器 界面優雅，體驗良好
    前言 本文介紹一款使用 C# 與 WPF 開發的音頻播放器，其界面簡潔大方，操作體驗流暢。該播放器支持多種音頻格式（如 MP4、WMA、OGG、FLAC 等），並具備標記、實時歌詞顯示等功能。 另外，還支持換膚及多語言（中英文）切換。核心音頻處理採用 FFmpeg 組件，獲得了廣泛認可，目前 Git ...
  • OAuth2.0授權-gitee授權碼模式
    OAuth2.0授權驗證-gitee授權碼模式 本文主要介紹如何筆者自己是如何使用gitee提供的OAuth2.0協議完成授權驗證並登錄到自己的系統，完整模式如圖 1、創建應用 打開gitee個人中心->第三方應用->創建應用 創建應用後在我的應用界面，查看已創建應用的Client ID和Clien ...
  • FastReport.OpenSource .Net下開源免費報表列印組件
    解決了這個問題：《winForm下，fastReport.net 從.net framework 升級到.net5遇到的錯誤“Operation is not supported on this platform.”》 本文內容轉載自：https://www.fcnsoft.com/Home/Sho ...
  • 如何在 ASP.NET Core Web API 方法執行前後 “偷偷“ 作一些 “壞“ 事？初識 ActionFilterAttribute
    國內文章 WPF 從裸 Win 32 的 WM_Pointer 消息獲取觸摸點繪製筆跡 https://www.cnblogs.com/lindexi/p/18390983 本文將告訴大家如何在 WPF 裡面，接收裸 Win 32 的 WM_Pointer 消息，從消息裡面獲取觸摸點信息，使用觸摸點 ...
  • 在 ASP.NET Core Web API 中使用異常篩選器捕獲和統一處理異常
    前言 給大家推薦一個專為新零售快消行業打造了一套高效的進銷存管理系統。 系統不僅具備強大的庫存管理功能，還集成了高性能的輕量級 POS 解決方案，確保頁面載入速度極快，提供良好的用戶體驗。 項目介紹 Dorisoy.POS 是一款基於 .NET 7 和 Angular 4 開發的新零售快消進銷存管理 ...
  • AbpHelper CLI積累與實戰分享
    ABP CLI常用的代碼分享 一、確保環境配置正確 安裝.NET CLI： ABP CLI是基於.NET Core或.NET 5/6/7等更高版本構建的，因此首先需要在你的開發環境中安裝.NET CLI。這可以通過訪問Microsoft官網下載並安裝相應版本的.NET SDK來實現。 安裝ABP ...
  • 記一次HttpClient使用問題分析
    問題 問題是這樣的：第三方的webapi，需要先調用登陸介面獲取Cookie，訪問其它介面時攜帶Cookie信息。 但使用HttpClient類調用登陸介面，返回的Headers中沒有找到Cookie信息。 分析 首先，使用Postman測試該登陸介面，正常返回Cookie信息，說明是HttpCli ...
  • .NET周刊【9月第3期 2024-09-15】
    國內文章 關於.NET在中國為什麼工資低的分析 https://www.cnblogs.com/thinkingmore/p/18406244 .NET在中國開發者的薪資偏低，主要因市場需求、技術棧選擇和企業文化等因素所致。歷史上，.NET曾因微軟的閉源策略發展受限，儘管後來推出了跨平臺的.NET ...
  • 我的網站集成ElasticSearch初體驗
    在WPF開發應用中，動畫不僅可以引起用戶的註意與興趣，而且還使軟體更加便於使用。前面幾篇文章講解了畫筆（Brush），形狀（Shape），幾何圖形（Geometry），變換（Transform）等相關內容，今天繼續講解動畫相關內容和知識點，僅供學習分享使用，如有不足之處，還請指正。 ...
  • 第23篇 委托的概述
    什麼是委托？ 委托可以說是把一個方法代入另一個方法執行，相當於指向函數的指針；事件就相當於保存委托的數組； 1.實例化委托的方式： 方式1：通過new創建實例： public delegate void ShowDelegate(); 或者 public delegate string ShowDe ...
所有分類