【Java Stream详解】

---

前言

Java Stream 是 Java 8 引入的一项强大特性，主要用于处理集合数据。它提供了类似于函数式编程的方式，使代码更加简洁、易读，同时提高了效率。本文将详细介绍 Stream 的基本概念、常用操作、使用场景。

---

一、Stream概述

1.1 什么是 Stream？

Stream 是 Java 8 中引入的一个新接口，它专注于对集合对象进行处理，支持类似 SQL 的操作，例如：过滤、映射、排序、统计、收集等。Stream 提供了链式操作方式，使代码简洁且易读。

1.2 Stream 和集合的区别

特性	Stream	集合
数据存储方式	不存储数据，仅处理数据流	存储数据
是否可复用	只能使用一次	可重复使用
是否支持惰性求值	惰性求值，仅在终端操作时才会执行	不支持惰性求值
并行处理	支持多核并行处理	不支持直接并行处理

---

二、Stream的创建方式

2.1 基于集合创建

import java.util.stream.Stream;
import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = List.of("Java", "Python", "C++", "Go");

        // 将集合转换为 Stream
        Stream<String> stream = list.stream();
        stream.forEach(System.out::println);
    }
}

2.2 基于数组创建

import java.util.stream.Stream;

public class StreamFromArray {
    public static void main(String[] args) {
        String[] languages = {"Java", "Python", "C++"};
        Stream<String> stream = Stream.of(languages);
        stream.forEach(System.out::println);
    }
}

2.3 使用 Stream.generate()

import java.util.stream.Stream;

public class StreamGenerate {
    public static void main(String[] args) {
        // 无限流，生成随机数，限制输出5个
        Stream<Double> randomStream = Stream.generate(Math::random).limit(5);
        randomStream.forEach(System.out::println);
    }
}

2.4 使用 Stream.iterate()

import java.util.stream.Stream;

public class StreamIterate {
    public static void main(String[] args) {
        // 从1开始，每次加2，生成偶数流
        Stream<Integer> stream = Stream.iterate(1, n -> n + 2).limit(5);
        stream.forEach(System.out::println);
    }
}

---

三、Stream常见操作

3.1 中间操作（Intermediate）

中间操作返回新的流对象，不会触发终端操作。常见的中间操作包括：

• filter(Predicate)：过滤元素
• map(Function)：映射操作
• flatMap(Function)：扁平化操作
• sorted(Comparator)：排序
• distinct()：去重
• limit(n)：限制流中元素个数
• skip(n)：跳过前 n 个元素

① filter：过滤元素

import java.util.stream.Stream;

public class FilterDemo {
    public static void main(String[] args) {
        Stream.of("Java", "Python", "Go", "C++")
              .filter(lang -> lang.length() > 3)
              .forEach(System.out::println);
    }
}

② map：映射操作

将元素转换为新的形式：

import java.util.stream.Stream;

public class MapDemo {
    public static void main(String[] args) {
        Stream.of("java", "python", "c++")
              .map(String::toUpperCase)
              .forEach(System.out::println);
    }
}

③ flatMap：扁平化处理

将流中的元素展开成单个元素流：

import java.util.stream.Stream;

public class FlatMapDemo {
    public static void main(String[] args) {
        Stream.of("Java,Python", "Go,C++")
              .flatMap(lang -> Stream.of(lang.split(",")))
              .forEach(System.out::println);
    }
}

④ sorted：排序

对流进行排序：

import java.util.stream.Stream;

public class SortedDemo {
    public static void main(String[] args) {
        Stream.of(5, 3, 8, 1, 2)
              .sorted()
              .forEach(System.out::println);
    }
}

3.2 终端操作（Terminal）

终端操作会触发流的执行，并返回结果。常见的终端操作包括：

• forEach(Consumer)：遍历
• collect(Collectors)：收集
• count()：计数
• reduce(BinaryOperator)：合并
• min(Comparator) 和 max(Comparator)：最小值和最大值
• anyMatch、allMatch 和 noneMatch：匹配操作

① collect：将流转换为集合

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectDemo {
    public static void main(String[] args) {
        List<String> list = Stream.of("Java", "Python", "Go")
                                  .collect(Collectors.toList());
        System.out.println(list);
    }
}

② reduce：合并元素

import java.util.stream.Stream;

public class ReduceDemo {
    public static void main(String[] args) {
        int sum = Stream.of(1, 2, 3, 4)
                        .reduce(0, Integer::sum);
        System.out.println("Sum: " + sum);
    }
}

---

四、并行流处理

Java Stream 支持多线程并行处理，通过 parallelStream() 可以实现自动并行计算。

import java.util.List;

public class ParallelStreamDemo {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

        // 并行流处理
        numbers.parallelStream()
               .map(num -> num * 2)
               .forEach(System.out::println);
    }
}

---

五、使用 Stream 处理用户数据

import java.util.List;
import java.util.stream.Collectors;

class User {
    String name;
    int age;

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

public class StreamCase {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User("Alice", 23),
            new User("Bob", 30),
            new User("Charlie", 27),
            new User("David", 35)
        );

        // 筛选年龄大于25岁的用户，并按年龄排序
        List<String> names = users.stream()
                                  .filter(u -> u.age > 25)
                                  .sorted((u1, u2) -> Integer.compare(u1.age, u2.age))
                                  .map(u -> u.name)
                                  .collect(Collectors.toList());

        System.out.println("筛选结果: " + names);
    }
}

---

六、总结

1. Stream 提供了简洁、易读的集合操作方式，常用于数据过滤、映射、聚合等操作。
2. 中间操作返回新的流对象，不执行终端操作不会触发计算。
3. 终端操作触发流的计算并返回结果。
4. 并行流可轻松实现多线程并行处理。

✅ 使用 Stream 可以提高代码的可读性和开发效率，尤其在集合数据处理时非常实用！