本文目录导读：
我将为你提供一系列Java Stream操作的实用案例,从基础到进阶。
基础Stream操作
import java.util.*;
import java.util.stream.*;
import java.util.function.*;
public class StreamBasics {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 1. 过滤偶数并打印
numbers.stream()
.filter(n -> n % 2 == 0)
.forEach(System.out::println); // 输出：2 4 6 8 10
// 2. 映射：将每个元素平方
List<Integer> squares = numbers.stream()
.map(n -> n * n)
.collect(Collectors.toList());
System.out.println("平方: " + squares);
// 3. 排序
List<Integer> descSorted = numbers.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
System.out.println("降序: " + descSorted);
// 4. 去重
List<Integer> withDuplicates = Arrays.asList(1, 2, 2, 3, 3, 3, 4);
List<Integer> distinct = withDuplicates.stream()
.distinct()
.collect(Collectors.toList());
System.out.println("去重: " + distinct); // [1, 2, 3, 4]
}
}
终止操作 - 聚合功能
public class StreamTerminalOps {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 1. count - 统计数量
long count = numbers.stream().count();
System.out.println("数量: " + count); // 5
// 2. max/min - 最大最小值
Optional<Integer> max = numbers.stream().max(Integer::compareTo);
Optional<Integer> min = numbers.stream().min(Integer::compareTo);
System.out.println("最大值: " + max.get() + ", 最小值: " + min.get());
// 3. reduce - 归约
Optional<Integer> sum = numbers.stream()
.reduce((a, b) -> a + b);
System.out.println("求和: " + sum.get()); // 15
// 4. anyMatch/allMatch/noneMatch - 匹配判断
boolean hasEven = numbers.stream().anyMatch(n -> n % 2 == 0);
boolean allPositive = numbers.stream().allMatch(n -> n > 0);
boolean noneNegative = numbers.stream().noneMatch(n -> n < 0);
System.out.println("有偶数: " + hasEven); // true
// 5. findFirst/findAny
Optional<Integer> first = numbers.stream().findFirst();
Optional<Integer> any = numbers.parallelStream().findAny();
System.out.println("第一个: " + first.get());
}
}
Collector收集器 - 高级用法
public class StreamCollectors {
public static void main(String[] args) {
List<Person> people = Arrays.asList(
new Person("张三", 25, "北京", 8000.0),
new Person("李四", 30, "上海", 12000.0),
new Person("王五", 35, "北京", 15000.0),
new Person("赵六", 28, "广州", 9000.0),
new Person("孙七", 32, "上海", 11000.0)
);
// 1. toList/toSet/toMap
List<String> names = people.stream()
.map(Person::getName)
.collect(Collectors.toList());
Set<String> cities = people.stream()
.map(Person::getCity)
.collect(Collectors.toSet());
Map<String, Double> nameSalaryMap = people.stream()
.collect(Collectors.toMap(
Person::getName,
Person::getSalary
));
// 2. groupingBy - 分组
Map<String, List<Person>> byCity = people.stream()
.collect(Collectors.groupingBy(Person::getCity));
// 3. partitioningBy - 分区
Map<Boolean, List<Person>> partitioned = people.stream()
.collect(Collectors.partitioningBy(
p -> p.getSalary() > 10000
));
// 4. joining - 连接字符串
String namesJoined = people.stream()
.map(Person::getName)
.collect(Collectors.joining(", ", "[", "]"));
System.out.println("拼接: " + namesJoined);
// 5. summarizing - 统计信息
DoubleSummaryStatistics stats = people.stream()
.mapToDouble(Person::getSalary)
.summaryStatistics();
System.out.println("平均工资: " + stats.getAverage());
System.out.println("最高工资: " + stats.getMax());
// 6. collectingAndThen
List<String> unmodifiableNames = people.stream()
.map(Person::getName)
.collect(Collectors.collectingAndThen(
Collectors.toList(),
Collections::unmodifiableList
));
}
static class Person {
private String name;
private int age;
private String city;
private double salary;
Person(String name, int age, String city, double salary) {
this.name = name;
this.age = age;
this.city = city;
this.salary = salary;
}
// getters...
public String getName() { return name; }
public int getAge() { return age; }
public String getCity() { return city; }
public double getSalary() { return salary; }
}
}
复杂业务场景案例
public class StreamRealWorld {
static class Order {
int id;
String customer;
double amount;
String status;
List<String> items;
Order(int id, String customer, double amount, String status, List<String> items) {
this.id = id; this.customer = customer;
this.amount = amount; this.status = status; this.items = items;
}
}
public static void main(String[] args) {
List<Order> orders = Arrays.asList(
new Order(1, "Alice", 500, "completed", Arrays.asList("书", "笔")),
new Order(2, "Bob", 1200, "pending", Arrays.asList("电脑")),
new Order(3, "Alice", 300, "completed", Arrays.asList("杯子")),
new Order(4, "Charlie", 800, "completed", Arrays.asList("鼠标", "键盘")),
new Order(5, "Bob", 1500, "cancelled", Arrays.asList("显示器"))
);
// 场景1：统计已完成订单总额
double completedTotal = orders.stream()
.filter(o -> o.getStatus().equals("completed"))
.mapToDouble(Order::getAmount)
.sum();
System.out.println("已完成订单总额: " + completedTotal);
// 场景2：按客户分组并统计消费总额
Map<String, Double> customerSpending = orders.stream()
.filter(o -> o.getStatus().equals("completed"))
.collect(Collectors.groupingBy(
Order::getCustomer,
Collectors.summingDouble(Order::getAmount)
));
// 场景3：找出消费最高的客户（只考虑已完成订单）
String topCustomer = orders.stream()
.filter(o -> o.getStatus().equals("completed"))
.collect(Collectors.groupingBy(
Order::getCustomer,
Collectors.summingDouble(Order::getAmount)
))
.entrySet().stream()
.max(Map.Entry.comparingByValue())
.map(Map.Entry::getKey)
.orElse("无客户");
// 场景4：统计每个客户购买的商品品类数
Map<String, Long> customerItemCount = orders.stream()
.collect(Collectors.groupingBy(
Order::getCustomer,
Collectors.flatMapping(
o -> o.getItems().stream(),
Collectors.counting()
)
));
// 场景5：找出大额订单（超过1000）的客户
List<String> bigSpenders = orders.stream()
.filter(o -> o.getAmount() > 1000)
.filter(o -> !o.getStatus().equals("cancelled"))
.map(Order::getCustomer)
.distinct()
.collect(Collectors.toList());
// 场景6：复杂聚合 - 按状态和客户分组
Map<String, Map<String, List<Order>>> grouped = orders.stream()
.collect(Collectors.groupingBy(
Order::getStatus,
Collectors.groupingBy(Order::getCustomer)
));
// 场景7：订单Items扁平化处理
List<String> allItems = orders.stream()
.filter(o -> o.getStatus().equals("completed"))
.flatMap(o -> o.getItems().stream())
.distinct()
.sorted()
.collect(Collectors.toList());
// 场景8：使用parallelStream提高性能
double totalAmount = orders.parallelStream()
.filter(o -> o.getStatus().equals("completed"))
.mapToDouble(Order::getAmount)
.average()
.orElse(0);
}
}
自定义Collector和Stream操作
public class AdvancedStreamOperations {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
// 1. Stream.iterate - 无限流
Stream.iterate(0, n -> n + 2)
.limit(10)
.forEach(System.out::println); // 0 2 4 6 8 10 12 14 16 18
// 2. Stream.generate - 生成流
Stream.generate(() -> new Random().nextInt(100))
.limit(5)
.forEach(System.out::println);
// 3. 自定义归约
int product = numbers.stream()
.reduce(1, (a, b) -> a * b);
System.out.println("乘积: " + product); // 720
// 4. 循环流 - takeWhile/dropWhile (Java 9+)
List<Integer> taken = numbers.stream()
.takeWhile(n -> n < 4)
.collect(Collectors.toList());
System.out.println("取前面<4的数: " + taken); // [1, 2, 3]
List<Integer> dropped = numbers.stream()
.dropWhile(n -> n < 4)
.collect(Collectors.toList());
System.out.println("跳过前面<4的数: " + dropped); // [4, 5, 6]
// 5. 收集器组合
Map<Boolean, List<Integer>> partitioned = numbers.stream()
.collect(Collectors.partitioningBy(n -> n % 2 == 0));
System.out.println("偶数: " + partitioned.get(true));
System.out.println("奇数: " + partitioned.get(false));
// 6. 按数组分组
List<String> words = Arrays.asList("apple", "banana", "cherry");
Map<Integer, List<String>> byLength = words.stream()
.collect(Collectors.groupingBy(String::length));
System.out.println("按长度分组: " + byLength);
// 7. 收集到不可变集合
List<Integer> unmodifiable = numbers.stream()
.collect(Collectors.collectingAndThen(
Collectors.toList(),
Collections::unmodifiableList
));
// 8. 自定义聚合
class Stats {
int sum;
int count;
void accumulate(int value) {
sum += value;
count++;
}
Stats combine(Stats other) {
sum += other.sum;
count += other.count;
return this;
}
double average() {
return count > 0 ? (double) sum / count : 0;
}
}
// 并行收集
double avg = numbers.parallelStream()
.collect(Stats::new, Stats::accumulate, Stats::combine)
.average();
System.out.println("平均值: " + avg);
// 9. 使用Stream进行XML/JSON处理模拟
List<Map<String, String>> data = Arrays.asList(
Map.of("name", "Alice", "dept", "IT"),
Map.of("name", "Bob", "dept", "Sales"),
Map.of("name", "Charlie", "dept", "IT")
);
Map<String, List<String>> deptNames = data.stream()
.collect(Collectors.groupingBy(
m -> m.get("dept"),
Collectors.mapping(m -> m.get("name"), Collectors.toList())
));
}
}
这些案例覆盖了Java Stream的主要功能,包括：
- 基础操作：filter, map, sorted, distinct
- 终止操作：count, max/min, reduce, match, find
- 收集器：toList, toMap, groupingBy, partitioningBy
- 真实业务场景：订单管理、客户分析等
- 高级特性：无限流、自定义收集器、并行流
你可以根据实际需求选择相应的Stream操作来简化代码并提高效率。
