java stream如何使用

發布時間：2022-10-24 11:41:08 來源：億速云閱讀：179 作者：iii 欄目：編程語言

Java Stream 如何使用

引言

Java 8 引入了 Stream API，它提供了一種高效且聲明式的方式來處理集合數據。Stream 允許開發者以函數式編程的風格處理數據，使得代碼更加簡潔、易讀。本文將詳細介紹 Stream 的使用方法，包括如何創建 Stream、中間操作、終端操作、并行流、性能考慮、與集合的區別、常見用例以及局限性。

Stream 簡介

Stream 是 Java 8 引入的一個新抽象，它允許開發者以聲明式的方式處理數據集合。Stream 不是數據結構，它不存儲數據，而是對數據進行操作。Stream 的操作可以分為兩類：中間操作和終端操作。

中間操作：返回一個新的 Stream，可以鏈式調用多個中間操作。
終端操作：觸發 Stream 的處理并返回結果，終端操作執行后，Stream 不能再被使用。

創建 Stream

從集合創建 Stream

最常見的創建 Stream 的方式是從集合中創建。Java 8 為 Collection 接口添加了 stream() 和 parallelStream() 方法，用于創建順序流和并行流。

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();
Stream<String> parallelStream = list.parallelStream();

從數組創建 Stream

可以使用 Arrays.stream() 方法從數組創建 Stream。

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

使用 Stream.of() 創建 Stream

Stream.of() 方法可以接受任意數量的參數，并返回一個包含這些參數的 Stream。

Stream<String> stream = Stream.of("a", "b", "c");

使用 Stream.iterate() 創建 Stream

Stream.iterate() 方法可以生成一個無限流，它接受一個初始值和一個函數，函數用于生成下一個值。

Stream<Integer> stream = Stream.iterate(0, n -> n + 2);

使用 Stream.generate() 創建 Stream

Stream.generate() 方法可以生成一個無限流，它接受一個 Supplier 函數，用于生成流中的元素。

Stream<Double> stream = Stream.generate(Math::random);

從文件創建 Stream

可以使用 Files.lines() 方法從文件中創建 Stream。

Stream<String> lines = Files.lines(Paths.get("file.txt"));

中間操作

中間操作是 Stream 的核心部分，它們返回一個新的 Stream，允許鏈式調用多個操作。常見的中間操作包括 filter、map、flatMap、distinct、sorted、peek 等。

filter

filter 方法用于過濾 Stream 中的元素，它接受一個 Predicate 函數，返回一個包含滿足條件元素的 Stream。

Stream<String> stream = Stream.of("a", "b", "c");
Stream<String> filteredStream = stream.filter(s -> s.startsWith("a"));

map

map 方法用于將 Stream 中的每個元素映射為另一個元素，它接受一個 Function 函數，返回一個包含映射后元素的 Stream。

Stream<String> stream = Stream.of("a", "b", "c");
Stream<String> mappedStream = stream.map(String::toUpperCase);

flatMap

flatMap 方法用于將 Stream 中的每個元素映射為一個 Stream，然后將這些 Stream 合并為一個 Stream。

Stream<List<String>> stream = Stream.of(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);
Stream<String> flatMappedStream = stream.flatMap(List::stream);

distinct

distinct 方法用于去除 Stream 中的重復元素。

Stream<String> stream = Stream.of("a", "b", "a");
Stream<String> distinctStream = stream.distinct();

sorted

sorted 方法用于對 Stream 中的元素進行排序。

Stream<String> stream = Stream.of("c", "a", "b");
Stream<String> sortedStream = stream.sorted();

peek

peek 方法用于對 Stream 中的每個元素執行操作，通常用于調試。

Stream<String> stream = Stream.of("a", "b", "c");
Stream<String> peekedStream = stream.peek(System.out::println);

終端操作

終端操作是 Stream 的最后一步，它觸發 Stream 的處理并返回結果。常見的終端操作包括 forEach、collect、reduce、count、min、max、anyMatch、allMatch、noneMatch、findFirst、findAny 等。

forEach

forEach 方法用于對 Stream 中的每個元素執行操作。

Stream<String> stream = Stream.of("a", "b", "c");
stream.forEach(System.out::println);

collect

collect 方法用于將 Stream 中的元素收集到一個集合中。

Stream<String> stream = Stream.of("a", "b", "c");
List<String> list = stream.collect(Collectors.toList());

reduce

reduce 方法用于將 Stream 中的元素歸約為一個值。

Stream<Integer> stream = Stream.of(1, 2, 3);
Optional<Integer> sum = stream.reduce(Integer::sum);

count

count 方法用于返回 Stream 中元素的數量。

Stream<String> stream = Stream.of("a", "b", "c");
long count = stream.count();

min

min 方法用于返回 Stream 中的最小元素。

Stream<Integer> stream = Stream.of(1, 2, 3);
Optional<Integer> min = stream.min(Integer::compareTo);

max

max 方法用于返回 Stream 中的最大元素。

Stream<Integer> stream = Stream.of(1, 2, 3);
Optional<Integer> max = stream.max(Integer::compareTo);

anyMatch

anyMatch 方法用于判斷 Stream 中是否有元素滿足條件。

Stream<String> stream = Stream.of("a", "b", "c");
boolean anyMatch = stream.anyMatch(s -> s.startsWith("a"));

allMatch

allMatch 方法用于判斷 Stream 中的所有元素是否都滿足條件。

Stream<String> stream = Stream.of("a", "b", "c");
boolean allMatch = stream.allMatch(s -> s.startsWith("a"));

noneMatch

noneMatch 方法用于判斷 Stream 中是否沒有元素滿足條件。

Stream<String> stream = Stream.of("a", "b", "c");
boolean noneMatch = stream.noneMatch(s -> s.startsWith("d"));

findFirst

findFirst 方法用于返回 Stream 中的第一個元素。

Stream<String> stream = Stream.of("a", "b", "c");
Optional<String> first = stream.findFirst();

findAny

findAny 方法用于返回 Stream 中的任意一個元素。

Stream<String> stream = Stream.of("a", "b", "c");
Optional<String> any = stream.findAny();

并行流

Stream 支持并行處理，可以通過 parallel() 方法將順序流轉換為并行流。并行流利用多核處理器的優勢，可以顯著提高處理速度。

Stream<String> stream = Stream.of("a", "b", "c");
Stream<String> parallelStream = stream.parallel();

并行流的注意事項

線程安全：并行流操作可能會涉及多個線程，因此需要確保操作是線程安全的。
性能開銷：并行流的創建和管理需要額外的開銷，對于小數據集，順序流可能更快。
順序性：并行流的處理順序是不確定的，如果需要保持順序，可以使用 forEachOrdered 方法。

Stream 的性能考慮

Stream 的性能受多種因素影響，包括數據量、操作類型、并行處理等。以下是一些性能優化的建議：

避免不必要的中間操作：每個中間操作都會創建一個新的 Stream，增加額外的開銷。
使用并行流：對于大數據集，并行流可以顯著提高處理速度。
選擇合適的終端操作：不同的終端操作有不同的性能特點，選擇合適的操作可以提高性能。

Stream 與集合的區別

Stream 和集合都是用于處理數據的工具，但它們有一些重要的區別：

數據存儲：集合存儲數據，而 Stream 不存儲數據。
數據處理：集合支持增刪改查操作，而 Stream 只支持數據處理操作。
延遲執行：Stream 的操作是延遲執行的，只有在終端操作觸發時才會執行。
不可重復使用：Stream 只能被使用一次，終端操作執行后，Stream 不能再被使用。

Stream 的常見用例

過濾和映射

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> result = names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

歸約操作

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
    .reduce(0, Integer::sum);

分組和分區

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Map<Integer, List<String>> grouped = names.stream()
    .collect(Collectors.groupingBy(String::length));

并行處理

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> result = names.parallelStream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Stream 的局限性

盡管 Stream 提供了強大的數據處理能力，但它也有一些局限性：

不可重復使用：Stream 只能被使用一次，終端操作執行后，Stream 不能再被使用。
調試困難：由于 Stream 的操作是延遲執行的，調試時可能難以追蹤問題。
性能開銷：Stream 的操作需要額外的開銷，對于小數據集，傳統的循環可能更快。

總結

Stream 是 Java 8 引入的一個強大工具，它提供了一種高效且聲明式的方式來處理集合數據。通過 Stream，開發者可以以函數式編程的風格處理數據，使得代碼更加簡潔、易讀。本文詳細介紹了 Stream 的使用方法，包括如何創建 Stream、中間操作、終端操作、并行流、性能考慮、與集合的區別、常見用例以及局限性。希望本文能幫助你更好地理解和使用 Stream。

向AI問一下細節