发呆的个人博客

关于Java Stream流

什么是Stream流

Java Stream 是 Java 8 引入的一个新的抽象层，用于处理集合数据的函数式编程工具。它提供了一种更为简洁、灵活和可读性更强的方式来处理集合数据。以下是 Java Stream 的一些优点：

  1. 函数式编程风格： Stream 提供了一种函数式编程的风格，使得代码更为简洁、可读，并且易于理解。它允许开发者使用函数式接口、Lambda 表达式等来进行集合操作，减少了样板代码。

  2. 惰性求值： Stream 使用惰性求值（Lazy Evaluation）的方式进行操作。这意味着在对集合进行操作时，只有在需要结果时才会执行实际的计算。这样可以提高效率，因为不会对整个集合进行不必要的操作。

  3. 并行处理： Stream 提供了并行处理的能力，可以通过调用 parallel() 方法将顺序流转换为并行流。这样可以充分利用多核处理器的优势，提高处理大数据集合的效率。

  4. 内置丰富的操作： Stream 提供了丰富的中间操作和终端操作，如 filter、map、reduce 等，这些操作使得开发者能够以一种声明式的方式进行数据处理，而不是通过编写循环和条件语句来实现。

  5. 无副作用： Stream 操作通常是无状态且无副作用的，这意味着它们不会修改底层数据结构，而是通过生成新的 Stream 进行操作。这有助于编写更为干净、可维护的代码。

  6. 可组合性： 多个 Stream 操作可以被组合在一起，形成一个复杂的数据处理流水线。这使得代码更为灵活，可以通过简单地组合操作来实现复杂的数据处理需求。

  7. 更好的性能： 在某些情况下，使用 Stream 可以提供比传统循环更好的性能，特别是在使用并行流进行大数据集合处理时。

总的来说，Java Stream 提供了一种更为现代、函数式的编程方式，使得集合操作变得更加简单、清晰和高效。

获取

你可以通过多种方式来获取一个 Stream 流。以下是一些常见的方法：

1. 从集合获取流：

List<String> list = Arrays.asList("apple", "banana", "orange");
​
// 从List获取流
Stream<String> streamFromList = list.stream();
​
// 从Set获取流
Set<String> set = new HashSet<>(list);
Stream<String> streamFromSet = set.stream();

2. 从数组获取流：

String[] array = {"apple", "banana", "orange"};
​
// 从数组获取流
Stream<String> streamFromArray = Arrays.stream(array);

3. 通过 Stream.of() 创建流：

Stream<String> streamOfElements = Stream.of("apple", "banana", "orange");

4. 使用 Stream.builder() 构建流：

Stream<String> streamBuilder = Stream.<String>builder()
    .add("apple")
    .add("banana")
    .add("orange")
    .build();

5. 通过 Stream.generate() 生成流：

// 生成一个无限长度的流，通过 limit 限制长度
Stream<String> generatedStream = Stream.generate(() -> "element").limit(5);

6. 通过 Stream.iterate() 生成流：

// 生成一个无限长度的流，通过 limit 限制长度
Stream<Integer> iterateStream = Stream.iterate(0, n -> n + 2).limit(5);

7. 通过 Files.lines() 读取文件内容生成流：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;
​
// 从文件中读取行生成流
try (Stream<String> lines = Files.lines(Paths.get("path/to/file.txt"))) {
    // 处理流
} catch (IOException e) {
    e.printStackTrace();
}

这些是一些获取 Stream 流的常见方式。选择适当的方式取决于你的数据源和需求。一旦你有了一个 Stream，你就可以使用 Stream API 中的各种操作来处理数据。

使用

Java Stream 提供了丰富的操作方法，可以分为中间操作和终端操作两种。中间操作用于构建一个流水线（pipeline），而终端操作则触发流水线的执行。以下是一些常用的 Stream 操作：

中间操作

  1. filter(Predicate<T> predicate)： 用于根据指定条件过滤元素。

    List<String> filteredList = list.stream()
                               .filter(s -> s.length() > 5)
                               .collect(Collectors.toList());

  2. map(Function<T, R> mapper)： 用于将元素通过指定的映射函数转换。

    List<Integer> lengths = list.stream()
                           .map(String::length)
                           .collect(Collectors.toList());

  3. flatMap(Function<T, Stream<R>> mapper)： 将每个元素映射为一个流，然后将这些流连接成一个流。

    List<String> flatList = listOfLists.stream()
                                  .flatMap(List::stream)
                                  .collect(Collectors.toList());

  4. distinct()： 用于去除重复元素。

    List<String> distinctList = list.stream()
                                .distinct()
                                .collect(Collectors.toList());

  5. sorted() 和 sorted(Comparator<T> comparator)： 用于对元素进行排序。

    List<String> sortedList = list.stream()
                             .sorted()
                             .collect(Collectors.toList());

List<String> customSorted = list.stream()
                               .sorted(Comparator.reverseOrder())
                               .collect(Collectors.toList());

  6. peek(Consumer<T> action)： 用于在流中的每个元素执行操作，主要用于调试。

    list.stream()
    .peek(System.out::println)
    .collect(Collectors.toList());

  7. limit(long maxSize) 和 skip(long n)： 用于限制结果集的大小或跳过元素。

    List<String> limitedList = list.stream()
                              .limit(5)
                              .collect(Collectors.toList());

List<String> skippedList = list.stream()
                              .skip(3)
                              .collect(Collectors.toList());

终端操作：

  1. collect(Collector<T, A, R> collector)： 用于将流元素转换成集合或其他形式。

    List<String> collectedList = list.stream()
                                .collect(Collectors.toList());

  2. forEach(Consumer<T> action)： 对流中的每个元素执行操作。

    list.stream()
    .forEach(System.out::println);

  3. reduce(BinaryOperator<T> accumulator) 和 reduce(T identity, BinaryOperator<T> accumulator)： 用于将流中的元素组合起来。

    Optional<String> concatenated = list.stream()
                                   .reduce((s1, s2) -> s1 + s2);

String result = list.stream()
                    .reduce("", (s1, s2) -> s1 + s2);

  4. count()： 返回流中的元素个数。

    long count = list.stream().count();

  5. anyMatch(Predicate<T> predicate)、allMatch(Predicate<T> predicate) 和 noneMatch(Predicate<T> predicate)： 用于检查是否有元素匹配给定的条件。

    boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("A"));
boolean allMatch = list.stream().allMatch(s -> s.length() > 3);
boolean noneMatch = list.stream().noneMatch(s -> s.contains("X"));

  6. findFirst() 和 findAny()： 用于返回流中的第一个元素。

    Optional<String> firstElement = list.stream().findFirst();
Optional<String> anyElement = list.stream().findAny();

这些只是 Stream 操作的一部分，Java 提供的 Stream API 还有其他一些操作和方法，使得对集合的处理变得更加简便和灵活。

Hello,World!

© 2025 发呆的个人博客