Java Stream API 中常用的流处理方法及示例，帮助你高效处理集合数据

Java Stream API 中常用的流处理方法及示例，帮助你高效处理集合数据：

一、中间操作（Intermediate Operations）

中间操作会返回一个新的流，可链式调用多个操作。

1. 过滤（Filter）

筛选符合条件的元素：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList()); // [2, 4]

2. 映射（Map）

将元素转换为新形式：

List<String> names = Arrays.asList("Alice", "Bob");
List<Integer> lengths = names.stream()
    .map(String::length)
    .collect(Collectors.toList()); // [5, 3]

3. 去重（Distinct）

移除重复元素：

List<Integer> duplicates = Arrays.asList(1, 2, 2, 3);
List<Integer> unique = duplicates.stream()
    .distinct()
    .collect(Collectors.toList()); // [1, 2, 3]

4. 排序（Sorted）

对元素排序：

List<String> unsorted = Arrays.asList("Z", "A", "M");
List<String> sorted = unsorted.stream()
    .sorted()
    .collect(Collectors.toList()); // [A, M, Z]

5. 切片（Limit/Skip）

限制/跳过元素数量：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 取前2个元素：[1, 2]
List<Integer> limited = numbers.stream().limit(2).collect(Collectors.toList());
// 跳过前2个元素：[3, 4, 5]
List<Integer> skipped = numbers.stream().skip(2).collect(Collectors.toList());

6. 扁平化（FlatMap）

将嵌套流合并为单一流：

List<List<Integer>> nested = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4));
List<Integer> flattened = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList()); // [1, 2, 3, 4]

7. ** peek（调试用）**

在流处理过程中打印元素（不改变元素）：

numbers.stream()
    .peek(System.out::println) // 打印每个元素
    .filter(n -> n > 2)
    .collect(Collectors.toList());

二、终端操作（Terminal Operations）

终端操作会终止流并返回结果。

1. 遍历（forEach）

对每个元素执行操作：

numbers.stream()
    .forEach(n -> System.out.print(n + " ")); // 输出：1 2 3 4 5

2. 收集（Collect）

将流转换为集合或其他结构：

// 转为 List
List<String> list = names.stream().collect(Collectors.toList());
// 转为 Set
Set<Integer> set = numbers.stream().collect(Collectors.toSet());
// 转为 Map（键需唯一）
Map<String, Integer> map = names.stream()
    .collect(Collectors.toMap(name -> name, String::length));

3. 归约（Reduce）

将元素组合为一个值：

int sum = numbers.stream()
    .reduce(0, Integer::sum); // 0 + 1 + 2 + 3 + 4 + 5 = 15

4. 统计（Count、Max、Min）

long count = numbers.stream().count(); // 元素个数
Optional<Integer> max = numbers.stream().max(Integer::compareTo); // 最大值
Optional<Integer> min = numbers.stream().min(Integer::compareTo); // 最小值

5. 分组（GroupingBy）

按属性分组：

Map<Integer, List<String>> groupByLength = names.stream()
    .collect(Collectors.groupingBy(String::length));
// 输出：{5=[Alice], 3=[Bob]}

6. 分区（PartitioningBy）

按布尔条件分区：

Map<Boolean, List<Integer>> evenOdd = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));
// 输出：{true=[2,4], false=[1,3,5]}

三、其他常用方法

1. 匹配（AnyMatch、AllMatch、NoneMatch）

boolean hasEven = numbers.stream().anyMatch(n -> n % 2 == 0); // 是否存在偶数
boolean allPositive = numbers.stream().allMatch(n -> n > 0); // 是否全为正数
boolean noneZero = numbers.stream().noneMatch(n -> n == 0); // 是否无零

2. 查找（FindFirst、FindAny）

Optional<Integer> first = numbers.stream().findFirst(); // 第一个元素（1）
Optional<Integer> any = numbers.stream().findAny(); // 任意元素（并行流中可能不同）

四、示例：链式操作

List<String> names = Arrays.asList("Apple", "Banana", "Cherry", "Date");

// 需求：过滤出长度>5的单词，转为大写，排序后转为逗号分隔字符串
String result = names.stream()
    .filter(name -> name.length() > 5) // ["Banana", "Cherry"]
    .map(String::toUpperCase) // ["BANANA", "CHERRY"]
    .sorted() // ["BANANA", "CHERRY"]
    .collect(Collectors.joining(", ")); // "BANANA, CHERRY"

五、注意事项

1. 惰性求值：中间操作只有在终端操作触发时才会执行。
2. 不可变性：流不会修改原始数据。
3. 并行流：通过 stream().parallel() 可启用并行处理，但需注意线程安全。

根据具体需求选择合适的方法组合，可显著简化集合处理逻辑。