[T] 遍历:forEach()
📋 方法签名
void forEach(Consumer<? super T> action)
参数说明：
- Consumer<? super T> action - 对流中每个元素执行的操作，是一个消费型函数式接口
返回值：
void - 无返回值，这是一个终端操作
💡 使用提示：
forEach是终端操作，调用后Stream结束。适合遍历处理，但不能改变Stream中的元素。在并行Stream中要注意线程安全问题。
forEach() 用于遍历Stream中的每个元素，是Stream中最基本的操作。
🔴 传统写法的痛点：
// 传统的for-each循环
for (Student student : students) {
System.out.println("学生姓名: " + student.getName());
System.out.println("学生年龄: " + student.getAge());
}
// 传统for循环（需要处理索引）
for (int i = 0; i < students.size(); i++) {
Student student = students.get(i);
System.out.println("第" + (i + 1) + "个学生: " + student.getName());
}🟢 Stream forEach() 解决方案：
// 简洁的forEach
students.stream()
.forEach(student -> {
System.out.println("学生姓名: " + student.getName());
System.out.println("学生年龄: " + student.getAge());
});
// 使用方法引用（更简洁）
students.stream()
.forEach(System.out::println);
// 带索引的遍历（需要额外处理）
AtomicInteger index = new AtomicInteger(0);
students.stream()
.forEach(student -> {
System.out.println("第" + (index.incrementAndGet()) + "个学生: " + student.getName());
});💡 使用场景和注意事项：
- 遍历处理：需要对每个元素执行相同操作时
- 终端操作：forEach是终端操作，调用后Stream结束
- 无返回值：不能在forEach中返回结果，适合副作用操作
- 并行安全：在并行Stream中要注意线程安全问题
forEach() 让遍历操作更加简洁，但要注意它是终端操作且不能改变Stream中的元素！
筛选:filter()
📋 方法签名
Stream<T> filter(Predicate<? super T> predicate)
参数说明：
- Predicate<? super T> predicate - 断言型函数式接口，返回true表示保留元素，false表示过滤掉
返回值：
Stream<T> - 包含所有满足predicate条件的元素的新Stream
💡 使用提示：
filter是中间操作，是惰性求值的。可以链式调用多个filter来组合复杂的筛选条件。通常将筛选操作放在链式调用的前面以减少处理的数据量。
筛选操作用于根据条件过滤元素，是Stream中最常用的操作之一。
🔍 filter() - 条件过滤
// 传统写法 - 繁琐
List<Student> adults = new ArrayList<>();
for (Student s : students) {
if (s.getAge() >= 18) {
adults.add(s);
}
}
// Stream写法 - 简洁
List<Student> adults = students.stream()
.filter(student -> student.getAge() >= 18)
.collect(Collectors.toList());
// 复杂条件筛选
List<Student> qualifiedStudents = students.stream()
.filter(s -> s.getAge() >= 18 && s.getScore() > 80 && s.isActive())
.collect(Collectors.toList());
// 多次filter链式调用（可读性更好）
List<Student> result = students.stream()
.filter(s -> s.getAge() >= 18) // 年龄筛选
.filter(s -> s.getScore() > 80) // 成绩筛选
.filter(Student::isActive) // 状态筛选
.collect(Collectors.toList());筛选:distinct()
📋 方法签名
Stream<T> distinct()
参数说明：
- 无参数 - 使用元素的equals()和hashCode()方法进行去重判断
返回值：
Stream<T> - 去重后的新Stream，对于有序流保持原始顺序
💡 使用提示：
distinct是中间操作，会去除流中的重复元素。需要元素正确实现equals()和hashCode()方法。对于大型数据集，distinct()的性能开销可能较大。
筛选操作用于根据条件过滤元素，是Stream中最常用的操作之一。
🔄 distinct() - 去重筛选
// 传统写法 - 需要Set辅助
Set<String> uniqueNames = new HashSet<>();
List<String> uniqueNameList = new ArrayList<>();
for (Student s : students) {
String name = s.getName();
if (uniqueNames.add(name)) { // Set.add()返回true表示元素不存在
uniqueNameList.add(name);
}
}
// Stream写法 - 优雅
List<String> uniqueNames = students.stream()
.map(Student::getName)
.distinct()
.collect(Collectors.toList());
// 对自定义对象去重（需要重写equals和hashCode）
List<Student> uniqueStudents = students.stream()
.distinct()
.collect(Collectors.toList());映射:map()
📋 方法签名
<R> Stream<R> map(Function<? super T, ? extends R> mapper)
参数说明：
- Function<? super T, ? extends R> mapper - 函数式接口，将类型为T的元素转换为类型为R的元素
返回值：
Stream<R> - 包含转换后元素的新Stream，元素类型可能不同
💡 使用提示：
map是中间操作，可以改变Stream中元素的类型。常用于数据转换、对象属性提取、格式转换等场景。map操作是一对一的映射，每个输入元素只产生一个输出元素。
映射操作用于转换Stream中的元素类型或结构，是Stream API的核心功能。
🔄 map() - 类型转换
// 传统写法 - 需要显式循环
List<String> names = new ArrayList<>();
for (Student student : students) {
names.add(student.getName());
}
// Stream写法 - 简洁
List<String> names = students.stream()
.map(Student::getName)
.collect(Collectors.toList());
// 复杂转换
List<StudentDTO> dtos = students.stream()
.map(student -> {
StudentDTO dto = new StudentDTO();
dto.setName(student.getName());
dto.setAge(student.getAge());
return dto;
})
.collect(Collectors.toList());
// 多步转换
List<Integer> nameLengths = students.stream()
.map(Student::getName) // Student -> String
.map(String::length) // String -> Integer
.collect(Collectors.toList());🔢 基本类型映射：
// 基本类型映射 - 避免自动装箱
IntStream ages = students.stream()
.mapToInt(Student::getAge);
DoubleStream scores = students.stream()
.mapToDouble(Student::getScore);
LongStream ids = students.stream()
.mapToLong(Student::getId);
// 基本类型Stream的优势
double averageAge = students.stream()
.mapToInt(Student::getAge)
.average()
.orElse(0.0); // 无需Optional处理映射操作是Stream的核心，map()用于一对一转换，flatMap()用于一对多扁平化！
映射:flatMap()
📋 方法签名
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
参数说明：
- Function<? super T, ? extends Stream<? extends R>> mapper - 将每个元素映射为一个Stream的函数式接口
返回值：
Stream<R> - 扁平化后的新Stream，包含所有子Stream的元素
💡 使用提示：
flatMap是中间操作，实现一对多映射。常用于处理嵌套集合、数组展开、对象扁平化等场景。flatMap会自动将多个Stream合并为一个Stream。
映射操作用于转换Stream中的元素类型或结构，是Stream API的核心功能。
📦 flatMap() - 扁平化映射
// 场景：学生选课列表，获取所有课程名称
List<Student> students = getStudents();
// 传统写法 - 嵌套循环
List<String> allCourses = new ArrayList<>();
for (Student student : students) {
for (Course course : student.getCourses()) {
allCourses.add(course.getName());
}
}
// Stream写法 - 使用flatMap扁平化
List<String> allCourses = students.stream()
.flatMap(student -> student.getCourses().stream()) // 将List<Course>扁平化为Stream<Course>
.map(Course::getName)
.distinct()
.collect(Collectors.toList());
// 字符串分割并扁平化
List<String> words = Arrays.asList("hello world", "java stream", "functional programming")
.stream()
.flatMap(sentence -> Arrays.stream(sentence.split(" ")))
.distinct()
.collect(Collectors.toList());
// 结果: ["hello", "world", "java", "stream", "functional", "programming"]映射操作是Stream的核心，map()用于一对一转换，flatMap()用于一对多扁平化！
排序:sorted()
📋 方法签名
Stream<T> sorted()
Stream<T> sorted(Comparator<? super T> comparator)
参数说明：
- Comparator<? super T> comparator - 比较器，用于定义排序规则（可选参数）
返回值：
Stream<T> - 排序后的新Stream
💡 使用提示：
sorted是中间操作，有参数版本使用自定义比较器，无参数版本要求元素实现Comparable接口。sorted是状态ful操作，需要处理所有元素才能完成排序，对性能有影响。
排序操作用于对Stream中的元素进行排序，支持自然排序和自定义排序。
📊 sorted() - 基础排序
// 传统写法 - 修改原集合
List<Student> students = new ArrayList<>(originalStudents);
Collections.sort(students);
// 或者使用Comparator
students.sort(Comparator.comparing(Student::getScore));
// Stream写法 - 不修改原集合
List<Student> sortedStudents = students.stream()
.sorted() // 自然排序（需要实现Comparable）
.collect(Collectors.toList());
// 使用Comparator排序
List<Student> sortedByScore = students.stream()
.sorted(Comparator.comparing(Student::getScore))
.collect(Collectors.toList());
// 降序排序
List<Student> sortedByScoreDesc = students.stream()
.sorted(Comparator.comparing(Student::getScore).reversed())
.collect(Collectors.toList());🎯 复杂排序规则：
// 多级排序：先按年龄，再按成绩，最后按姓名
List<Student> multiSort = students.stream()
.sorted(Comparator
.comparing(Student::getAge) // 一级排序：年龄
.thenComparing(Student::getScore) // 二级排序：成绩
.thenComparing(Student::getName)) // 三级排序：姓名
.collect(Collectors.toList());
// 自定义排序规则
List<Student> customSort = students.stream()
.sorted((s1, s2) -> {
// 自定义复杂排序逻辑
int scoreCompare = Double.compare(s2.getScore(), s1.getScore()); // 成绩降序
if (scoreCompare != 0) return scoreCompare;
return s1.getName().compareTo(s2.getName()); // 姓名升序
})
.collect(Collectors.toList());⚡ 排序性能考虑：
// 排序后使用limit()获取前N名 - 性能优化
List<Student> top3Students = students.stream()
.sorted(Comparator.comparing(Student::getScore).reversed())
.limit(3) // 只取前3名，减少排序开销
.collect(Collectors.toList());
// 注意：在并行Stream中使用sorted()可能影响性能
List<Student> sortedResult = students.parallelStream()
.sorted(Comparator.comparing(Student::getScore))
.collect(Collectors.toList()); // 并行排序开销较大💡 实际应用场景：
- 排行榜：按成绩、分数等排序
- 数据展示：按时间、字母顺序展示
- 优先级处理：按重要性、紧急程度排序
- 数据分析：有序的数据处理
提取:limit()
📋 方法签名
Stream<T> limit(long maxSize)
参数说明：
- long maxSize - 要提取的最大元素数量，不能为负数
返回值：
Stream<T> - 截取后的新Stream，最多包含maxSize个元素
💡 使用提示：
limit是中间操作，是短路操作。通常用于分页处理、获取前N个元素、限制处理数据量等场景。在并行Stream中，limit的行为可能不保证顺序。
limit(n) 用于截取 Stream 中的前 n 个元素。
✂️ limit() - 截取前 N 个
// 传统写法 - 需要索引控制
List<Student> first5Students = new ArrayList<>();
for (int i = 0; i < Math.min(5, students.size()); i++) {
first5Students.add(students.get(i));
}
// Stream写法 - 简洁
List<Student> first5Students = students.stream()
.limit(5) // 只取前5个元素
.collect(Collectors.toList());
💡 场景： 获取 Top N 数据、数据采样、避免处理过多数据。
提取:skip()
📋 方法签名
Stream<T> skip(long n)
参数说明：
- long n - 要跳过的元素数量，不能为负数
返回值：
Stream<T> - 跳过后剩余元素的新Stream
💡 使用提示：
skip是中间操作，常与limit()配合实现分页功能。适用于跳过前N个元素、实现偏移量等场景。如果n大于Stream长度，返回空Stream。
skip(n) 用于跳过 Stream 中的前 n 个元素，返回剩下的元素。
⏭️ skip() - 跳过前 N 个
// 获取除了前 5 名之外的学生
List<Student> restStudents = students.stream()
.skip(5) // 跳过前5个
.collect(Collectors.toList());
// 分页操作：结合 skip + limit
int pageSize = 10;
int pageNumber = 2; // 第2页
List<Student> pageData = students.stream()
.skip((pageNumber - 1) * pageSize) // 跳过前面的元素
.limit(pageSize) // 取当前页的元素
.collect(Collectors.toList());
💡 场景： 分页查询、忽略表头/首行数据。
[T] 提取:findFirst()
📋 方法签名
Optional<T> findFirst()
参数说明：
- 无参数 - 返回Stream中的第一个元素
返回值：
Optional<T> - 包含第一个元素的Optional，如果Stream为空则返回Optional.empty()
💡 使用提示：
findFirst是终端操作和短路操作。在并行Stream中总是返回第一个元素（按顺序），具有确定性。常用于查找符合条件的第一个元素。
findFirst() 返回 Stream 中的第一个元素（包装在 Optional 中）。
🥇 findFirst() - 查找第一个
// 传统写法 - 需要循环和 break
Student firstAdult = null;
for (Student student : students) {
if (student.getAge() >= 18) {
firstAdult = student;
break;
}
}
// Stream写法 - 优雅且语义清晰
Optional<Student> firstAdult = students.stream()
.filter(student -> student.getAge() >= 18)
.findFirst();
// 处理结果
String name = firstAdult
.map(Student::getName)
.orElse("未找到成年学生");
💡 注意： 在有序流中（如 List），它总是返回第一个元素；在无序流中（如 HashSet），结果可能不确定。
[T] 提取:findAny()
📋 方法签名
Optional<T> findAny()
参数说明：
- 无参数 - 返回Stream中的任意一个元素
返回值：
Optional<T> - 包含任意一个元素的Optional，如果Stream为空则返回Optional.empty()
💡 使用提示：
findAny是终端操作和短路操作。在并行Stream中性能可能更好，但不保证返回哪个元素。当不关心具体返回哪个元素，只需要任意一个时使用。
findAny() 返回 Stream 中的任意一个元素（包装在 Optional 中）。
🎲 findAny() - 查找任意一个
// findAny() - 在并行 Stream (parallelStream) 中性能更好
// 因为它不需要等待"第一个"元素，只要有线程找到符合条件的就返回
Optional<Student> anyAdult = students.parallelStream()
.filter(student -> student.getAge() >= 18)
.findAny();
// 配合短路操作 anyMatch (返回 boolean)
boolean hasHighScorer = students.stream()
.anyMatch(student -> student.getScore() > 95);
💡 区别：
findFirst()：追求顺序确定性，适合有序流。findAny()：追求性能，适合并行流 (Parallel Stream)，不关心具体是哪一个。
[T] 统计:count()
📋 方法签名
long count()
参数说明：
- 无参数 - 返回Stream中的元素数量
返回值：
long - Stream中的元素总数，如果Stream为空则返回0
💡 使用提示：
count是终端操作，会遍历整个Stream来计算元素数量。对于大型Stream或无限Stream，可能需要配合limit()等短路操作使用。在并行Stream中性能更好。
count() 是一个终结操作，用于返回 Stream 中的元素总数。
🔢 count() - 计数操作
// 传统写法 - 需要计数器
int adultCount = 0;
for (Student student : students) {
if (student.getAge() >= 18) {
adultCount++;
}
}
// Stream写法 - 简洁
long adultCount = students.stream()
.filter(student -> student.getAge() >= 18)
.count();
// 分组统计：配合 Collectors.counting()
Map<String, Long> countByGender = students.stream()
.collect(Collectors.groupingBy(
Student::getGender,
Collectors.counting()
));
💡 注意：
count() 返回的是 long 类型，不是 int。
[T] 统计:min() & max()
📋 方法签名
Optional<T> min(Comparator<? super T> comparator)
Optional<T> max(Comparator<? super T> comparator)
参数说明：
- Comparator<? super T> comparator - 比较器，用于定义元素的比较规则
返回值：
Optional<T> - 包含最小/最大值的Optional，如果Stream为空则返回Optional.empty()
💡 使用提示：
min/max是终端操作，需要提供比较器。对于数值类型，建议使用专门的数值Stream操作。如果元素已经实现Comparable接口，可以使用Comparator.naturalOrder()。
min() 和 max() 根据指定的比较器，返回 Stream 中的最小值或最大值（包装在 Optional 中）。
📉 min() - 查找最小值
// 查找年龄最小的学生
Optional<Student> youngestStudent = students.stream()
.min(Comparator.comparing(Student::getAge));
// 获取最小年龄数值 (IntStream)
// mapToInt 将 Stream 转换为 IntStream
int minAge = students.stream()
.mapToInt(Student::getAge)
.min()
.orElse(0); // 如果流为空，返回默认值 0
💡 技巧： 使用
mapToInt/mapToDouble 等转为基本类型流后，min() 会返回 OptionalInt 等特化类型。
[T] 统计:max()
📋 方法签名
Optional<T> max(Comparator<? super T> comparator)
参数说明：
- Comparator<? super T> comparator - 比较器，用于定义元素的比较规则
返回值：
Optional<T> - 包含最大值的Optional，如果Stream为空则返回Optional.empty()
💡 使用提示：
max是终端操作，需要提供比较器。对于数值类型，建议使用专门的数值Stream操作。如果元素已经实现Comparable接口，可以使用Comparator.naturalOrder()。
max() 根据指定的比较器，返回 Stream 中的最大值（包装在 Optional 中）。
📈 max() - 查找最大值
// 查找分数最高的学生
Optional<Student> topStudent = students.stream()
.max(Comparator.comparing(Student::getScore));
// 复杂场景：查找"大四"学生中分数最高的
Optional<Student> bestSenior = students.stream()
.filter(s -> "Senior".equals(s.getGrade()))
.max(Comparator.comparing(Student::getScore));[T] 统计:sum()
📋 方法签名
int sum() // IntStream
long sum() // LongStream
double sum() // DoubleStream
参数说明：
- 无参数 - 仅适用于数值Stream (IntStream, LongStream, DoubleStream)
返回值：
int/long/double - Stream中所有元素的和，空Stream返回对应类型的默认值
💡 使用提示：
sum是终端操作，专用于数值Stream。需要通过mapToInt()、mapToLong()、mapToDouble()将对象Stream转换为数值Stream。对于大数值计算要注意溢出问题。
sum() 用于对数值流（IntStream, LongStream, DoubleStream）中的元素求和。
➕ sum() - 求和计算
// 传统写法
double totalScore = 0;
for (Student s : students) {
totalScore += s.getScore();
}
// Stream写法
// 注意：sum() 仅在基本类型流(IntStream等)中可用
double totalScore = students.stream()
.mapToDouble(Student::getScore)
.sum();
// 复杂求和：计算所有商品的折后总价
double totalValue = products.stream()
.mapToDouble(p -> p.getPrice() * p.getDiscount())
.sum();
⚠️ 警告： 普通
Stream<T> 没有 sum() 方法，必须先通过 mapToInt/mapToLong/mapToDouble 转换。
[T] 规约:reduce()
📋 方法签名
Optional<T> reduce(BinaryOperator<T> accumulator)
T reduce(T identity, BinaryOperator<T> accumulator)
<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)
参数说明：
- T identity - 初始值，用于第一次累加操作
- BinaryOperator<T> accumulator - 累加器函数，定义如何组合两个元素
- BiFunction<U, ? super T, U> accumulator - 转换累加器，用于类型转换场景
- BinaryOperator<U> combiner - 合并器函数，用于并行Stream的结果合并
返回值：
Optional<T>/T/U - 规约结果：无初始值时返回Optional，有初始值时返回具体类型
💡 使用提示：
reduce是最灵活的终端操作，可用于求和、求积、字符串拼接等任意聚合操作。有初始值的版本更安全。在并行Stream中，combiner函数用于合并各线程的局部结果。
reduce() 操作用于将Stream中的元素按照指定的规则"规约"成一个值，是最灵活的聚合操作。
🔄 基础reduce() - 求和示例
// 传统写法 - 显式累加
double totalScore = 0;
for (Student student : students) {
totalScore += student.getScore();
}
// Stream写法 - reduce()规约
Optional<Double> totalScore = students.stream()
.map(Student::getScore)
.reduce((score1, score2) -> score1 + score2);
// 带初始值的reduce() - 避免Optional
double totalScoreWithInit = students.stream()
.map(Student::getScore)
.reduce(0.0, Double::sum);
// 使用方法引用更简洁
double totalScoreMethodRef = students.stream()
.map(Student::getScore)
.reduce(0.0, Double::sum);⚙️ 自定义规约逻辑
// 找出最高分的学生
Optional<Student> topStudent = students.stream()
.reduce((s1, s2) -> s1.getScore() > s2.getScore() ? s1 : s2);
// 字符串拼接 - 传统方式
String allNames1 = students.stream()
.map(Student::getName)
.reduce("", (name1, name2) -> name1 + ", " + name2);
// 字符串拼接 - 更优雅的方式
String allNames2 = students.stream()
.map(Student::getName)
.collect(Collectors.joining(", "));
// 复杂对象规约 - 计算加权平均
WeightedAverageResult weightedAvg = students.stream()
.reduce(
new WeightedAverageResult(0.0, 0.0), // 初始值
(result, student) -> new WeightedAverageResult(
result.totalScore + student.getScore() * student.getCredit(),
result.totalCredit + student.getCredit()
),
(result1, result2) -> new WeightedAverageResult(
result1.totalScore + result2.totalScore,
result1.totalCredit + result2.totalCredit
)
);🎯 reduce() vs collect() 的选择
// reduce() - 返回单一值，适合聚合操作
Integer maxValue = numbers.stream()
.reduce(Integer::max)
.orElse(0);
// collect() - 返回集合，适合收集操作
List<Integer> positiveNumbers = numbers.stream()
.filter(n -> n > 0)
.collect(Collectors.toList());
// reduce() - 自定义聚合逻辑
String concatenated = words.stream()
.reduce("", String::concat);
// collect() - 标准收集操作
List<String> wordList = words.stream()
.collect(Collectors.toList());⚡ 性能考虑：
- 并行安全：reduce()需要满足结合律才能安全并行执行
- 初始值选择：带初始值的reduce()可以避免Optional处理
- 身份元素：初始值应该是操作的身份元素（如加法的0、乘法的1）
- 性能优化：对于简单聚合，优先使用专门的统计方法（sum、count等）
reduce() 是Stream中最强大的聚合操作，可以实现任何自定义的聚合逻辑！
[T] 收集:collect()
📋 方法签名
<R, A> R collect(Collector<? super T, A, R> collector)
<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner)
参数说明：
- Collector<? super T, A, R> collector - 收集器，定义如何收集元素到结果容器中
- Supplier<R> supplier - 结果容器的工厂方法
- BiConsumer<R, ? super T> accumulator - 累加器，定义如何将元素添加到容器中
- BiConsumer<R, R> combiner - 合并器，用于并行Stream时合并两个容器
返回值：
R - 收集结果，可以是List、Set、Map或任意自定义类型
💡 使用提示：
collect是最灵活的终端操作，Collectors类提供了丰富的预定义收集器。常用场景：toList()、toSet()、toMap()、groupingBy()、partitioningBy()等。自定义收集器可以实现复杂的数据转换需求。
collect() 是Stream的终端操作，用于将Stream中的元素收集到容器中，是最灵活的结果收集方式。
📦 基础收集操作
// 收集到List
List<Student> studentList = students.stream()
.filter(s -> s.getAge() >= 18)
.collect(Collectors.toList());
// 收集到Set（自动去重）
Set<String> uniqueNames = students.stream()
.map(Student::getName)
.collect(Collectors.toSet());
// 收集到具体集合类型
ArrayList<Student> arrayList = students.stream()
.filter(s -> s.getScore() > 80)
.collect(Collectors.toCollection(ArrayList::new));
// 收集到Map - 简单映射
Map<Integer, Student> studentMap = students.stream()
.collect(Collectors.toMap(
Student::getId, // key mapper
student -> student // value mapper
));
// 收集到Map - 处理重复键
Map<String, Student> nameToStudent = students.stream()
.collect(Collectors.toMap(
Student::getName, // key mapper
student -> student, // value mapper
(existing, replacement) -> existing // 合并函数：保留现有值
));📊 分组操作 - groupingBy()
// 按专业分组
Map<String, List<Student>> studentsByMajor = students.stream()
.collect(Collectors.groupingBy(Student::getMajor));
// 分组并统计每组数量
Map<String, Long> countByMajor = students.stream()
.collect(Collectors.groupingBy(
Student::getMajor,
Collectors.counting()
));
// 分组并计算平均成绩
Map<String, Double> avgScoreByMajor = students.stream()
.collect(Collectors.groupingBy(
Student::getMajor,
Collectors.averagingDouble(Student::getScore)
));
// 多级分组
Map<String, Map<String, List<Student>>> multiLevelGroup = students.stream()
.collect(Collectors.groupingBy(
Student::getMajor, // 一级分组：专业
Collectors.groupingBy(student -> { // 二级分组：年龄段
int age = student.getAge();
if (age < 18) return "未成年";
else if (age < 25) return "青年";
else return "成年";
})
));✂️ 分区操作 - partitioningBy()
// 按是否成年分区（只返回true/false两个组）
Map<Boolean, List<Student>> byAdult = students.stream()
.collect(Collectors.partitioningBy(
student -> student.getAge() >= 18
));
// 分区并进行进一步收集
Map<Boolean, String> namesByAdult = students.stream()
.collect(Collectors.partitioningBy(
student -> student.getAge() >= 18,
Collectors.mapping(
Student::getName,
Collectors.joining(", ")
)
));🎯 高级收集操作
// 收集统计信息
IntSummaryStatistics ageStats = students.stream()
.collect(Collectors.summarizingInt(Student::getAge));
// 按条件收集（类似SQL的CASE WHEN）
Map<String, List<Student>> scoreCategories = students.stream()
.collect(Collectors.groupingBy(student -> {
double score = student.getScore();
if (score >= 90) return "优秀";
else if (score >= 80) return "良好";
else if (score >= 70) return "中等";
else if (score >= 60) return "及格";
else return "不及格";
}));
// 自定义收集器
String result = students.stream()
.collect(CustomCollector.toCustomString());💡 实际应用场景：
- 数据报表：分组统计、汇总计算
- 数据转换：List到Map、Set等容器转换
- 数据分析：按多维度分类统计
- 结果封装：将Stream结果转换为业务对象
组合:concat()
📋 方法签名
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
参数说明：
- Stream<? extends T> a - 第一个要合并的Stream
- Stream<? extends T> b - 第二个要合并的Stream
返回值：
Stream<T> - 包含两个Stream所有元素的新Stream，保持原始顺序
💡 使用提示：
concat是静态方法，用于懒连接两个Stream。连接后的Stream会包含所有元素，先处理第一个Stream的所有元素，再处理第二个Stream。对于大型Stream，可能影响性能。
Stream的组合操作可以将多个流合并为一个流，方便统一处理。
🔗 concat() - 流合并操作
// 传统写法 - 需要手动合并集合
List<Student> allStudents = new ArrayList<>(undergraduates);
allStudents.addAll(graduateStudents);
allStudents.addAll(exchangeStudents);
// Stream写法 - 流合并
Stream<Student> allStudentStream = Stream.concat(
Stream.concat(undergraduates.stream(), graduateStudents.stream()),
exchangeStudents.stream()
);
// 多个流合并
Stream<Student> mergedStream = Stream.of(
undergraduates.stream(),
graduateStudents.stream(),
exchangeStudents.stream()
)
.flatMap(Function.identity()); // 扁平化合并
// 合并后进行统一处理
List<String> allStudentNames = Stream.concat(
undergraduates.stream(),
graduateStudents.stream()
)
.filter(student -> student.isActive()) // 统一筛选
.map(Student::getName) // 统一映射
.collect(Collectors.toList()); // 统一收集
💡 提示：
Stream.concat 是惰性求值的，只有在终端操作执行时才会真正合并。
并行操作:parallel()
📋 方法签名
Stream<T> parallel()
Stream<T> sequential()
boolean isParallel()
参数说明：
- 无参数 - parallel()转换为并行Stream，sequential()转换回顺序Stream，isParallel()检查是否并行
返回值：
Stream<T>/boolean - parallel/sequential返回新的Stream，isParallel返回当前并行状态
💡 使用提示：
parallel()适合CPU密集型操作和大数据集。要求数据源可分割、操作无状态、无依赖。并行操作可能改变元素处理顺序，可能影响排序和有序性。
Stream API 提供了极其简单的并行处理能力，充分利用多核 CPU 提升性能。
parallel() - 并行处理
默认并行路数 ：通常等于 Runtime.getRuntime().availableProcessors() - 1
例如，在8核心CPU上，默认并行路数为7。
// 串行处理（默认）
List<Student> result1 = students.stream()
.filter(s -> s.getAge() >= 18)
.collect(Collectors.toList());
// 并行处理 - 一行代码实现
List<Student> result2 = students.parallelStream() // 直接创建并行流
.filter(s -> s.getAge() >= 18)
.collect(Collectors.toList());
// 或者使用parallel()方法转换
List<Student> result3 = students.stream()
.parallel() // 转换为并行流
.filter(s -> s.getAge() >= 18)
.collect(Collectors.toList());
// 串行和并行混合使用
students.stream()
.filter(s -> s.getMajor().equals("计算机科学")) // 串行：简单筛选
.parallel() // 并行：复杂计算
.map(this::calculateComplexScore) // 并行计算
.sequential() // 串行：有序收集
.sorted(Comparator.comparing(Student::getScore))
.collect(Collectors.toList());🚀 并行处理性能优化
// 性能测试示例
List<Integer> largeList = IntStream.range(0, 1_000_000)
.boxed()
.collect(Collectors.toList());
// 串行处理时间
long start = System.currentTimeMillis();
long sum1 = largeList.stream()
.mapToLong(Integer::longValue)
.filter(n -> n % 2 == 0)
.sum();
long serialTime = System.currentTimeMillis() - start;
// 并行处理时间
start = System.currentTimeMillis();
long sum2 = largeList.parallelStream()
.mapToLong(Integer::longValue)
.filter(n -> n % 2 == 0)
.sum();
long parallelTime = System.currentTimeMillis() - start;
System.out.println("串行时间: " + serialTime + "ms");
System.out.println("并行时间: " + parallelTime + "ms");
System.out.println("加速比: " + (double) serialTime / parallelTime);⚠️ 并行处理注意事项：
// 适合并行处理的场景
List<ComplexData> result = largeDataSet.parallelStream()
.filter(data -> data.isValid()) // 无状态过滤
.map(this::expensiveComputation) // CPU密集型操作
.collect(Collectors.toList());
// 不适合并行处理的场景
List<Integer> result2 = smallList.stream() // 数据量小
.sorted() // 顺序敏感操作
.limit(5) // 短路操作
.collect(Collectors.toList());
// 线程安全问题示例
List<StringBuilder> unsafeResult = students.parallelStream()
.collect(ArrayList::new, // 这里有线程安全问题！
(list, student) -> list.add(new StringBuilder(student.getName())),
List::addAll);
// 正确的线程安全写法
List<String> safeResult = students.parallelStream()
.map(Student::getName)
.collect(Collectors.toList()); // 使用线程安全的收集器💡 最佳实践建议：
- 数据量判断：通常超过10000个元素才考虑并行
- 操作类型：CPU密集型操作适合并行，IO密集型不适合
- 无状态操作：确保操作函数是无状态的
- 性能测试：实际测试并行是否带来性能提升
- 避免过度并行：嵌套并行流会降低性能
1 / X