当前位置： 首页 > web >正文

Stream API 讲解

web 2025/8/30 6:07:30

1. Stream 的基本概念

什么是 Stream？

Stream 不是数据结构，而是对数据源（集合、数组等）的元素序列进行函数式操作的管道。

主要特点：

  • 不存储数据：只是数据的视图

  • 不修改源数据：操作产生新流，不影响原集合

  • 惰性操作：中间操作不会立即执行

  • 只能消费一次：流被终端操作消费后就不能再使用

2. Stream 操作的三种类型

2.1 创建流（Stream Creation）

// 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream1 = list.stream();
Stream<String> parallelStream = list.parallelStream();// 从数组创建
String[] array = {"a", "b", "c"};
Stream<String> stream2 = Arrays.stream(array);// 使用 Stream.of
Stream<String> stream3 = Stream.of("a", "b", "c");// 使用 Stream.generate（无限流）
Stream<Double> randomStream = Stream.generate(Math::random).limit(5);// 使用 Stream.iterate（无限流）
Stream<Integer> iterateStream = Stream.iterate(0, n -> n + 2).limit(10);

2.2 中间操作（Intermediate Operations）

返回新流，可以链式调用，都是惰性的。

filter - 过滤
List<String> filtered = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());
map - 转换
List<Integer> lengths = list.stream()           // 1. 创建Stream.map(String::length)                       // 2. 映射操作.collect(Collectors.toList());             // 3. 收集结果// flatMap - 扁平化
List<List<String>> nestedList = Arrays.asList(Arrays.asList("a", "b"),Arrays.asList("c", "d")
);
List<String> flatList = nestedList.stream().flatMap(Collection::stream).collect(Collectors.toList());

方法引用语法

User::getName 是以下方法引用的形式：

  • 类名::实例方法名

  • 表示对某个类的实例调用指定的方法

其他常见用法

// 字符串转大写
.map(String::toUpperCase)// 获取字符串长度
.map(String::length)// 调用静态方法
.map(Integer::valueOf)// 构造函数引用
.map(User::new)
distinct - 去重
List<String> distinct = Arrays.asList("a", "b", "a", "c").stream().distinct().collect(Collectors.toList());
sorted - 排序
List<String> sorted = list.stream().sorted().collect(Collectors.toList());// 自定义排序
List<String> customSorted = list.stream().sorted((s1, s2) -> s2.compareTo(s1)).collect(Collectors.toList());
limit 和 skip
List<String> limited = list.stream()           // 1. 创建Stream.limit(2)                                // 2. 限制数量.collect(Collectors.toList());           // 3. 收集结果List<String> skipped = list.stream()           // 1. 创建Stream.skip(1)                                 // 2. 跳过元素.collect(Collectors.toList());           // 3. 收集结果
peek - 查看元素（调试用）
List<String> result = list.stream().peek(System.out::println).map(String::toUpperCase).peek(System.out::println).collect(Collectors.toList());

2.3 终端操作（Terminal Operations）

触发流的处理，返回非流结果。

forEach - 遍历
list.stream().forEach(System.out::println);
collect - 收集结果
// 转换为List
List<String> listResult = stream.collect(Collectors.toList());// 转换为Set
Set<String> setResult = stream.collect(Collectors.toSet());// 转换为Map
Map<String, Integer> mapResult = list.stream().collect(Collectors.toMap(s -> s,           // key mapperString::length    // value mapper));// 分组
Map<Integer, List<String>> grouped = list.stream().collect(Collectors.groupingBy(String::length));// 分区
Map<Boolean, List<String>> partitioned = list.stream().collect(Collectors.partitioningBy(s -> s.length() > 3));
reduce - 归约
// 求和
Optional<Integer> sum = Arrays.asList(1, 2, 3).stream().reduce(Integer::sum);// 带初始值的reduce
Integer sumWithIdentity = Arrays.asList(1, 2, 3).stream().reduce(0, Integer::sum);// 复杂的reduce
String concatenated = Arrays.asList("a", "b", "c").stream().reduce("", (partial, element) -> partial + element);
匹配操作
boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("a"));
boolean allMatch = list.stream().allMatch(s -> s.length() > 2);
boolean noneMatch = list.stream().noneMatch(s -> s.isEmpty());
查找操作
Optional<String> first = list.stream().findFirst();
Optional<String> any = list.stream().findAny();
统计操作
 List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50);// 基本统计
long count = numbers.stream().count();
Optional<Integer> max = numbers.stream().max(Integer::compare);
Optional<Integer> min = numbers.stream().min(Integer::compare);System.out.println("Count: " + count);       // 输出: Count: 5
System.out.println("Max: " + max.orElse(0)); // 输出: Max: 50
System.out.println("Min: " + min.orElse(0)); // 输出: Min: 10// 数值流统计
IntSummaryStatistics stats = numbers.stream().mapToInt(Integer::intValue).summaryStatistics();System.out.println("=== 综合统计 ===");
System.out.println("Max: " + stats.getMax());        // 50
System.out.println("Min: " + stats.getMin());        // 10
System.out.println("Average: " + stats.getAverage());// 30.0
System.out.println("Sum: " + stats.getSum());        // 150
System.out.println("Count: " + stats.getCount());    // 5

3. 数值流特化

处理基本类型时更高效：

// IntStream
IntStream intStream = IntStream.range(1, 10); // 1-9
IntStream closedStream = IntStream.rangeClosed(1, 10); // 1-10// LongStream
LongStream longStream = LongStream.range(1, 100);// DoubleStream
DoubleStream doubleStream = DoubleStream.of(1.0, 2.0, 3.0);// 对象流转换为数值流
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
IntStream intStreamFromObjects = numbers.stream().mapToInt(Integer::intValue);

4. 并行流

并行流是 Java 8 中引入的一种能够自动将数据处理任务分配到多个线程并行执行的流。它基于 Fork/Join 框架，能够充分利用多核处理器的优势。

核心概念

1. 并行 vs 并发

  • 并发：多个任务交替执行（看起来同时）

  • 并行：多个任务真正同时执行（多核处理器）

2. 工作窃取（Work Stealing）

并行流使用 Fork/Join 框架，采用工作窃取算法：

  • 每个线程有自己的任务队列

  • 空闲线程可以从其他线程的队列末尾"偷取"任务

  • 提高CPU利用率，减少线程空闲时间

创建并行流的三种方式

方式1：直接创建并行流
List<String> list = Arrays.asList("a", "b", "c", "d", "e");// 使用 parallelStream() 直接创建并行流
List<String> parallelResult = list.parallelStream().map(String::toUpperCase).collect(Collectors.toList());
方式2：将顺序流转换为并行流
List<String> result = list.stream()        // 先创建顺序流.parallel()                           // 转换为并行流.map(String::toUpperCase).collect(Collectors.toList());
方式3：将并行流转换回顺序流
List<String> sequentialResult = list.parallelStream()  // 创建并行流.sequential()                                     // 转换回顺序流.map(String::toUpperCase).collect(Collectors.toList());

并行流的工作原理

数据分割（Splitting）
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);// 并行流会自动将数据分割成多个块
int sum = numbers.parallelStream().mapToInt(Integer::intValue).sum();// 相当于：
// 线程1处理: [1, 2, 3, 4, 5] → sum=15
// 线程2处理: [6, 7, 8, 9, 10] → sum=40
// 最终结果: 15 + 40 = 55
执行流程

  1. 分割：将数据源分割成多个子任务

  2. 处理：多个线程并行处理各自的数据块

  3. 合并：将各个线程的结果合并为最终结果

并行流的适用场景

✅ 适合使用并行流的场景

1. 数据量大的计算密集型任务

// 计算1到1千万的和
long sum = LongStream.rangeClosed(1, 10_000_000).parallel()  // 使用并行流大幅提升性能.sum();

2. 独立的元素处理

List<String> words = Arrays.asList("apple", "banana", "cherry", "date");// 每个字符串的处理是独立的
List<String> upperCaseWords = words.parallelStream().map(String::toUpperCase).collect(Collectors.toList());

3. 过滤操作

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);// 并行过滤偶数
List<Integer> evenNumbers = numbers.parallelStream().filter(n -> n % 2 == 0).collect(Collectors.toList());
❌ 不适合使用并行流的场景

1. 有状态的操作（可能产生错误结果）

// 错误的用法：skip() 和 limit() 在并行流中行为不确定
List<Integer> result = numbers.parallelStream().skip(2).limit(5).collect(Collectors.toList()); // 结果可能不一致

2. 有顺序依赖的操作

// 错误的用法：findFirst() 在并行流中可能返回任意第一个完成的元素
Optional<Integer> first = numbers.parallelStream().filter(n -> n > 5).findFirst(); // 结果不确定

3. 数据量太小

List<Integer> smallList = Arrays.asList(1, 2, 3);// 开销大于收益：创建线程的开销可能超过计算收益
long sum = smallList.parallelStream().mapToInt(Integer::intValue).sum();

5. 实战示例

示例1：数据处理管道

List<Person> people = Arrays.asList(new Person("Alice", 25, "New York"),new Person("Bob", 30, "London"),new Person("Charlie", 35, "New York"),new Person("David", 28, "Paris")
);// 复杂的流操作
Map<String, Double> averageAgeByCity = people.stream().filter(p -> p.getAge() > 25)                    // 过滤年龄>25.map(p -> {                                      // 转换城市名为大写p.setCity(p.getCity().toUpperCase());return p;}).sorted(Comparator.comparing(Person::getAge))    // 按年龄排序.collect(Collectors.groupingBy(                  // 按城市分组Person::getCity,Collectors.averagingInt(Person::getAge)      // 计算平均年龄));

示例2：文件处理

try (Stream<String> lines = Files.lines(Paths.get("data.txt"))) {List<String> longWords = lines.flatMap(line -> Arrays.stream(line.split("\\s+"))).filter(word -> word.length() > 5).distinct().sorted().collect(Collectors.toList());
} catch (IOException e) {e.printStackTrace();
}

示例3：数据库式查询

// 模拟SQL查询：SELECT name FROM users WHERE age > 25 ORDER BY name
List<String> result = users.stream().filter(user -> user.getAge() > 25).map(User::getName).sorted().collect(Collectors.toList());

6. 最佳实践和注意事项

性能考虑：

// 不好的写法：多次终端操作
long count = list.stream().filter(s -> s.length() > 3).count();
List<String> result = list.stream().filter(s -> s.length() > 3).collect(Collectors.toList());// 好的写法：重用流
Stream<String> filteredStream = list.stream().filter(s -> s.length() > 3);
long count = filteredStream.count();
// 注意：流只能消费一次，这里会抛出异常

避免副作用：

// 不好的写法：在流中修改外部状态
List<String> result = new ArrayList<>();
list.stream().filter(s -> s.length() > 3).forEach(result::add);  // 副作用！// 好的写法：使用collect
List<String> result = list.stream().filter(s -> s.length() > 3).collect(Collectors.toList());

空值处理：

List<String> safeList = Optional.ofNullable(list).orElse(Collections.emptyList()).stream().filter(Objects::nonNull).collect(Collectors.toList());

7. 常用的 Collectors 方法

// 连接字符串
String joined = list.stream().collect(Collectors.joining(", "));// 统计
Double average = list.stream().collect(Collectors.averagingInt(String::length));
Long count = list.stream().collect(Collectors.counting());// 最大最小值
Optional<String> max = list.stream().collect(Collectors.maxBy(Comparator.naturalOrder()));// 多级分组
Map<Integer, Map<String, List<Person>>> multiLevel = people.stream().collect(Collectors.groupingBy(Person::getAge,Collectors.groupingBy(Person::getCity)));

http://www.xdnf.cn/news/19164.html

相关文章：

  • Day17_【机器学习—在线数据集 鸢尾花案例】
  • 宜春城区SDH网图分析
  • 漫谈《数字图像处理》之浅析图割分割
  • 从9.4%到13.5%：ICDM2025录取率触底反弹，竞争压力稍缓
  • 新工具-mybatis-flex学习及应用
  • 大模型应用开发笔记（了解篇）
  • 使用 Bright Data Web Scraper API + Python 高效抓取 Glassdoor 数据：从配置到结构化输出全流程实战
  • Vue 项目首屏加载速度优化
  • 阿里云百炼智能体连接云数据库实践(DMS MCP)
  • AI-调查研究-64-机器人 从零构建机械臂：电机、减速器、传感器与控制系统全剖析
  • 深入解析Qt节点编辑器框架：交互逻辑与样式系统（二）
  • 如何使用 Vector 连接 Easysearch
  • cloudflare-ddns
  • nacos登录认证
  • 2026届大数据毕业设计选题推荐-基于Python的出行路线规划与推荐系统 爬虫数据可视化分析
  • 使用TensorFlow Lite Mirco 跑mirco_speech语音识别yes/no
  • Blender中旋转与翻转纹理的实用方法教学
  • Speculation Rules API
  • 华为HCIP数通学习与认证解析！
  • 从零开始的云计算生活——第五十四天，悬梁刺股，kubernetes模块之组件与网络
  • rapid_table v3.0.0发布了
  • MySQL数据库精研之旅第十四期：索引的 “潜规则”(上)
  • 新手向:Python实现数据可视化图表生成
  • 《R for Data Science (2e)》免费中文翻译 (第6章) --- scripts and projects
  • MySQL-内置函数
  • 【C++详解】C++11(一) 列表初始化、右值引⽤和移动语义
  • 2025五天申请邓白氏编码成功
  • 第八篇 永磁同步电机控制-MTPA、MTPV
  • 计算机网络：数据库(sqlite3)
  • 4.x版本的ant-table+sortablejs实现拖拽排序