快捷導(dǎo)航

Java中stream是什么及如何使用

更新時(shí)間：2023年10月27日 16:42:09 作者：SoftwareDevOps

在Java中,Stream（流）是一種用于操作集合（Collection）、數(shù)組等數(shù)據(jù)源的API,Stream的主要作用是進(jìn)行數(shù)據(jù)的轉(zhuǎn)換、篩選、聚合等操作,可以極大地簡(jiǎn)化對(duì)數(shù)據(jù)的處理,本文給大家介紹Java中stream是什么？有什么作用？如何使用？感興趣的朋友一起看看吧

Java中stream是什么？有什么作用？如何使用？

在Java中，Stream（流）是一種用于操作集合（Collection）、數(shù)組等數(shù)據(jù)源的API。它提供了一種功能強(qiáng)大且表達(dá)力高的編程模型，可以用更簡(jiǎn)潔、更具可讀性的方式處理數(shù)據(jù)。

Stream的主要作用是進(jìn)行數(shù)據(jù)的轉(zhuǎn)換、篩選、聚合等操作，可以極大地簡(jiǎn)化對(duì)數(shù)據(jù)的處理。使用Stream可以避免顯式地使用迭代器或循環(huán)來(lái)操作集合，提高代碼的可讀性和簡(jiǎn)潔性。

以下是使用Stream的一般步驟：

獲取一個(gè)數(shù)據(jù)源（如List、Set、數(shù)組等）。
調(diào)用stream()方法獲取數(shù)據(jù)流。
使用各種中間操作對(duì)數(shù)據(jù)流進(jìn)行處理（如篩選、轉(zhuǎn)換等）。
調(diào)用終端操作執(zhí)行對(duì)數(shù)據(jù)流的最終處理（如聚合、收集結(jié)果等）。

下面通過(guò)示例代碼詳細(xì)介紹Stream的使用：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
    public static void main(String[] args) {
        // 1. 獲取數(shù)據(jù)源
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // 2. 獲取數(shù)據(jù)流
        List<Integer> evenSquares = numbers.stream()
                // 3. 中間操作：篩選偶數(shù)并計(jì)算平方
                .filter(n -> n % 2 == 0)
                .map(n -> n * n)
                // 4. 終端操作：收集結(jié)果
                .collect(Collectors.toList());
        System.out.println(evenSquares); // 輸出：[4, 16, 36, 64, 100]
    }
}

在上述示例中，我們首先獲取了一個(gè)整數(shù)列表作為數(shù)據(jù)源。然后，通過(guò)調(diào)用stream()方法獲取了一個(gè)數(shù)據(jù)流。接著，使用中間操作filter()篩選出偶數(shù)，再使用map()計(jì)算平方。最后，通過(guò)終端操作collect()將結(jié)果收集到列表中。

這只是Stream的基本用法，Stream還提供了豐富的中間操作和終端操作供使用，如sorted()、distinct()、reduce()等。通過(guò)組合不同的操作，可以實(shí)現(xiàn)復(fù)雜的數(shù)據(jù)處理邏輯。

stream用法：

filter(Predicate<T> predicate)：根據(jù)指定的條件篩選元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());
// 輸出：[2, 4]

map(Function<T, R> mapper)：將元素轉(zhuǎn)換為另一種類型。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<String> result = list.stream().map(n -> "Number: " + n).collect(Collectors.toList());
// 輸出：["Number: 1", "Number: 2", "Number: 3", "Number: 4", "Number: 5"]

flatMap(Function<T, Stream<R>> mapper)：將流中的每個(gè)元素轉(zhuǎn)換為一個(gè)流，然后將所有流合并為一個(gè)流。

List<List<Integer>> lists = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4, 5));
List<Integer> result = lists.stream().flatMap(list -> list.stream()).collect(Collectors.toList());
// 輸出：[1, 2, 3, 4, 5]

distinct()：去除流中重復(fù)的元素。

List<Integer> list = Arrays.asList(1, 2, 3, 2, 4, 1, 5);
List<Integer> result = list.stream().distinct().collect(Collectors.toList());
// 輸出：[1, 2, 3, 4, 5]

sorted()：對(duì)流中元素進(jìn)行排序。

List<Integer> list = Arrays.asList(5, 3, 1, 2, 4);
List<Integer> result = list.stream().sorted().collect(Collectors.toList());
// 輸出：[1, 2, 3, 4, 5]

peek(Consumer<T> action)：對(duì)流中的元素執(zhí)行指定的操作。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream().peek(n -> System.out.println("Processing element: " + n)).collect(Collectors.toList());
// 輸出：Processing element: 1 Processing element: 2 Processing element: 3 Processing element: 4 Processing element: 5

limit(long maxSize)：截取流中的前N個(gè)元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream().limit(3).collect(Collectors.toList());
// 輸出：[1, 2, 3]

skip(long n)：跳過(guò)流中的前N個(gè)元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream().skip(3).collect(Collectors.toList());
// 輸出：[4, 5]

1.forEach(Consumer<T> action)：對(duì)流中的每個(gè)元素執(zhí)行指定的操作。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.stream().forEach(n -> System.out.println(n));
// 輸出：1 2 3 4 5

2.collect(Collector<T, A, R> collector)：將流中的元素收集到一個(gè)容器中。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());
// 輸出：[2, 4]

3.count()：返回流中的元素個(gè)數(shù)。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
long count = list.stream().count();
// 輸出：5

4.reduce(T identity, BinaryOperator<T> accumulator)：將流中的元素逐個(gè)與初始值進(jìn)行操作，返回最終結(jié)果。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, (a, b) -> a + b);
// 輸出：15

5.findFirst()和findAny()：返回流中的第一個(gè)元素或任意一個(gè)元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> first = list.stream().findFirst();
Optional<Integer> any = list.stream().findAny();
// 輸出：1

6.max()和min()：返回流中的最大元素或最小元素。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = list.stream().max(Integer::compareTo);
Optional<Integer> min = list.stream().min(Integer::compareTo);
// 輸出：5 1

7.allMatch(Predicate<T> predicate)、anyMatch(Predicate<T> predicate)和noneMatch(Predicate<T> predicate)：分別返回流中所有元素是否滿足指定條件、是否至少有一個(gè)元素滿足指定條件、是否沒有元素滿足指定條件。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean allMatch = list.stream().allMatch(n -> n > 0);
boolean anyMatch = list.stream().anyMatch(n -> n % 2 == 0);
boolean noneMatch = list.stream().noneMatch(n -> n > 5);
// 輸出：true true false

Stream是Java 8引入的一組 API，它提供了一種新的并行處理集合數(shù)據(jù)的方式，可以讓開發(fā)者更加方便、高效地對(duì)集合進(jìn)行操作。

Stream 是基于管道（Pipe）和過(guò)濾器（Filter）的模式，通過(guò)對(duì)數(shù)據(jù)源執(zhí)行一系列中間操作（Intermediate Operations）和終端操作（Terminal Operations）來(lái)完成對(duì)數(shù)據(jù)的處理。

利用 Stream API，我們可以在不改變?cè)袛?shù)據(jù)結(jié)構(gòu)的前提下，方便地進(jìn)行數(shù)據(jù)的篩選、排序、映射、聚合等操作，并且這些操作可以串行或并行地執(zhí)行，以提高計(jì)算效率。