萬字詳解 | 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
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類