Java Stream（详解）

目录

什么是Stream流

Stream流的获取

1. 从集合获取流：

2. 从数组获取流：

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

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

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

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

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

Stream API

中间操作（链式编程）

filter(Predicate predicate)： 用于根据指定条件过滤元素。

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

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

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

sorted() 和 sorted(Comparator comparator)： 用于对元素进行排序。

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

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

终端操作：

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

forEach(Consumer action)： 对流中的每个元素执行操作。

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

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

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

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

---

什么是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流的获取

你可以通过多种方式来获取一个 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 中的各种操作来处理数据。

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 还有其他一些操作和方法，使得对集合的处理变得更加简洁、灵活和高效。