Java Stream 流式编程

Java 8 引入的 Stream API 是一种 声明式 的数据处理方式，用于处理集合、数组等数据源。它将数据处理操作（如过滤、映射、排序、聚合）以链式方式组织，简化了集合的处理逻辑，提升了代码的可读性和可维护性。

---

一、Stream 的核心概念

1. 流（Stream）

• 流是一组元素的序列，支持顺序或并行处理。
• 流不是集合 ，它本身不存储数据，而是对数据源（如 List、Set、Map、数组等）进行操作。
• 流只能被消费一次，一旦执行终端操作，流就关闭，不能再使用。

2. 操作类型

Stream 的操作分为两类：

操作类型	说明	常见方法
中间操作（Intermediate Operations）	返回一个新的流，可以链式调用	filter()、map()、sorted()、distinct()
终端操作（Terminal Operations）	返回非流的结果（如 List、int、void）	collect()、forEach()、count()、findFirst()

---

二、Stream 的处理流程

List<String> result = list.stream()
.filter(s -> s.length() > 3)// 中间操作
.map(String::toUpperCase)// 中间操作
.sorted()// 中间操作
.collect(Collectors.toList());// 终端操作

流程图：

数据源（如 List） → 流 → 中间操作 → 中间操作 → ... → 终端操作 → 结果

---

三、常用操作与案例

1. 创建流（Stream）

// 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

// 从数组创建
String[] arr = {"x", "y", "z"};
Stream<String> stream2 = Arrays.stream(arr);

// 生成无限流
Stream<Integer> infiniteStream = Stream.iterate(1, n -> n + 1);

---

2. 中间操作

(1) filter(Predicate)：过滤符合条件的元素

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

(2) map(Function)：将元素映射为其他类型

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

(3) sorted(Comparator)：排序

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

(4) distinct()：去重

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

(5) limit(long) / skip(long)：截取或跳过

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

---

3. 终端操作

(1) collect(Collector)：收集结果（最常用）

List<String> listResult = stream.collect(Collectors.toList());
Set<String> setResult = stream.collect(Collectors.toSet());
Map<String, Integer> mapResult = stream.collect(Collectors.toMap(...));

(2) forEach(Consumer)：遍历

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

(3) count()：统计元素数量

long count = stream.count();

(4) findFirst() / findAny()：查找第一个或任意元素

Optional<String> first = stream.findFirst();

(5) anyMatch() / allMatch() / noneMatch()：匹配判断

boolean hasLong = stream.anyMatch(s -> s.length() > 3);

(6) reduce()：归约操作（如求和、最大值）

int sum = stream.mapToInt(Integer::intValue).sum();
Optional<Integer> max = stream.reduce(Integer::max);

---

四、高级用法与案例

1. 分组（Grouping By）

Map<String, List<User>> usersByGender = userList.stream()
.collect(Collectors.groupingBy(User::getGender));

2. 分区（Partitioning By）

Map<Boolean, List<User>> activeUsers = userList.stream()
.collect(Collectors.partitioningBy(User::isActive));

3. 统计（Summarizing）

IntSummaryStatistics stats = userList.stream()
.collect(Collectors.summarizingInt(User::getAge));

4. 多级分组

Map<String, Map<String, List<User>>> usersByGenderAndCity = userList.stream()
.collect(Collectors.groupingBy(User::getGender,
Collectors.groupingBy(User::getCity)));

5. 拼接字符串（Joining）

String names = userList.stream()
.map(User::getName)
.collect(Collectors.joining(", ")); // "Alice, Bob, Charlie"

---

五、并行流（Parallel Stream）

并行流利用多核 CPU 加速计算，适用于大数据量处理：

List<String> result = list.parallelStream()
.map(String::toUpperCase)
.collect(Collectors.toList());

⚠️ 注意：并行流不保证顺序，且对线程安全要求较高。

---

六、完整示例代码

import java.util.*;
import java.util.stream.Collectors;

class User {
private String name;
private int age;
private String gender;

public User(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}

public String getName() { return name; }
public int getAge() { return age; }
public String getGender() { return gender; }

@Override
public String toString() {
return name;
}
}

public class StreamDemo {
public static void main(String[] args) {
List<User> users = Arrays.asList(
new User("Alice", 25, "Female"),
new User("Bob", 30, "Male"),
new User("Charlie", 22, "Male"),
new User("Diana", 28, "Female")
);

// 案例1：过滤 + 映射 + 收集
List<String> maleNames = users.stream()
.filter(u -> "Male".equals(u.getGender()))
.map(User::getName)
.collect(Collectors.toList());
System.out.println("Male names: " + maleNames);

// 案例2：分组 + 统计
Map<String, Double> avgAgeByGender = users.stream()
.collect(Collectors.groupingBy(User::getGender,
Collectors.averagingInt(User::getAge)));
System.out.println("Average age by gender: " + avgAgeByGender);

// 案例3：并行流求和
int totalAge = users.parallelStream()
.mapToInt(User::getAge)
.sum();
System.out.println("Total age: " + totalAge);

// 案例4：查找最年长用户
Optional<User> oldest = users.stream()
.max(Comparator.comparing(User::getAge));
System.out.println("Oldest user: " + oldest.orElse(null));
}
}

---

七、Stream 的优势

优势	说明
声明式语法	用链式调用表达逻辑，代码更简洁
函数式编程支持	使用 Lambda 表达式简化操作
链式操作	支持中间操作的灵活组合
并行处理	利用多核 CPU 提升性能
内置丰富的操作	提供过滤、映射、分组、统计等工具

---

八、注意事项

1. 流只能消费一次：终端操作后，流关闭，再次使用会抛异常。
2. 避免副作用 ：中间操作（如 forEach）不应修改外部状态。
3. 性能权衡：小数据集使用普通循环更高效，大数据集使用并行流。
4. 线程安全：并行流操作需确保数据和操作是线程安全的。

---

九、总结

Java Stream 是一种 声明式 的数据处理工具，通过链式操作简化集合处理，提升了代码的可读性和可维护性。结合 Collectors、Optional、Comparator 等工具，可以轻松实现过滤、映射、分组、统计等复杂操作。合理使用 Stream 能显著提高开发效率和代码质量。