如何理解java中Stream流？

在Java中，Stream 是 Java 8 引入的一个强大API，用于处理集合（如 List、Set、Map 等）数据的流式操作。它提供了一种声明式、函数式的编程风格，可以高效地进行过滤、映射、排序、聚合等操作。

Stream 的核心概念

1. 流（Stream）：
   • 流是一个来自数据源（如集合、数组、I/O 资源）的元素序列。
   • 流本身不存储数据，而是按需计算。
   • 流操作分为中间操作（Intermediate Operations）和终端操作（Terminal Operations）。
2. 中间操作（Intermediate Operations）：
   • 中间操作会返回一个新的流，可以链式调用。
   • 常见的中间操作：filter()、map()、sorted()、distinct()、limit() 等。
   • 中间操作是惰性的，只有在终端操作触发时才会执行。
3. 终端操作（Terminal Operations）：
   • 终端操作会触发流的执行，并产生一个结果或副作用。
   • 常见的终端操作：forEach()、collect()、reduce()、count()、anyMatch() 等。
   • 终端操作执行后，流会被消耗，无法再次使用。

Stream 的特点

1. 声明式编程：
   • 通过方法链描述操作，代码更简洁易读。
   • 例如：list.stream().filter(...).map(...).collect(...)。
2. 惰性求值：
   • 中间操作不会立即执行，只有在终端操作触发时才会计算。
3. 并行处理：
   • 可以通过 parallelStream() 轻松实现并行处理，充分利用多核CPU。
4. 不可复用：
   • 流一旦被终端操作消费，就不能再次使用。

Stream 的常见操作

1. 创建流

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream(); // 从集合创建流
Stream<String> parallelStream = list.parallelStream(); // 创建并行流
Stream<Integer> numbers = Stream.of(1, 2, 3); // 直接创建流

2. 中间操作

• 过滤：filter()

  List<String> result = list.stream()
                            .filter(s -> s.startsWith("a")) // 过滤以 "a" 开头的元素
                            .collect(Collectors.toList());
  

• 映射：map()

  List<Integer> lengths = list.stream()
                              .map(String::length) // 将字符串映射为长度
                              .collect(Collectors.toList());
  

• 去重：distinct()

  List<String> unique = list.stream()
                            .distinct() // 去重
                            .collect(Collectors.toList());
  

• 排序：sorted()

  List<String> sorted = list.stream()
                            .sorted() // 自然排序
                            .collect(Collectors.toList());
  

• 限制：limit()

  List<String> firstTwo = list.stream()
                              .limit(2) // 只取前两个元素
                              .collect(Collectors.toList());
  

3. 终端操作

• 遍历：forEach()

  list.stream().forEach(System.out::println); // 打印每个元素
  

• 收集：collect()

  List<String> result = list.stream()
                            .filter(s -> s.length() > 1)
                            .collect(Collectors.toList()); // 收集为List
  

• 聚合：reduce()

  Optional<String> combined = list.stream()
                                  .reduce((s1, s2) -> s1 + "-" + s2); // 拼接字符串
  

• 匹配：anyMatch()、allMatch()、noneMatch()

  boolean hasA = list.stream().anyMatch(s -> s.contains("a")); // 是否有包含 "a" 的元素
  

• 计数：count()

  long count = list.stream().filter(s -> s.length() > 1).count(); // 统计符合条件的元素数量
  

并行流

通过 parallelStream() 可以轻松实现并行处理：

List<String> result = list.parallelStream()
                          .filter(s -> s.length() > 1)
                          .collect(Collectors.toList());

Stream 的优势

1. 代码简洁：通过链式调用，代码更易读。
2. 高效处理：支持并行处理，适合大数据量操作。
3. 函数式编程：支持 Lambda 表达式和方法引用，更符合现代编程风格。

总结

Stream 是 Java 8 引入的一个强大工具，用于以声明式的方式处理集合数据。它通过中间操作和终端操作的组合，提供了高效、简洁的数据处理能力，特别适合需要对集合进行复杂操作的场景。