Java 集合操作完整清单（Java 8+ Stream API）
Java 集合操作完整清单（Java 8+ Stream API）
给你一个完整的Java集合操作清单，包含代码示例。现代Java推荐使用Stream API进行集合操作。
1. 过滤操作
// 过滤符合条件的元素
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> even = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList()); // [2, 4, 6]
// 去重
List<Integer> withDups = Arrays.asList(1, 2, 2, 3, 3, 3);
List<Integer> distinct = withDups.stream()
.distinct()
.collect(Collectors.toList()); // [1, 2, 3]
// 分页（跳过前n个，取前m个）
List<Integer> paged = numbers.stream()
.skip(2)
.limit(3)
.collect(Collectors.toList()); // [3, 4, 5]
2. 映射操作
// 类型转换
List<String> strings = Arrays.asList("1", "2", "3");
List<Integer> ints = strings.stream()
.map(Integer::parseInt)
.collect(Collectors.toList()); // [1, 2, 3]
// 提取对象属性
List<User> users = getUsers();
List<String> names = users.stream()
.map(User::getName)
.collect(Collectors.toList());
// 扁平化（将多个集合合并为一个）
List<List<Integer>> nested = Arrays.asList(
Arrays.asList(1, 2),
Arrays.asList(3, 4)
);
List<Integer> flat = nested.stream()
.flatMap(List::stream)
.collect(Collectors.toList()); // [1, 2, 3, 4]
3. 排序操作
List<Integer> nums = Arrays.asList(3, 1, 4, 1, 5, 9);
// 自然排序（升序）
List<Integer> sorted = nums.stream()
.sorted()
.collect(Collectors.toList()); // [1, 1, 3, 4, 5, 9]
// 自定义排序（降序）
List<Integer> reversed = nums.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList()); // [9, 5, 4, 3, 1, 1]
// 按对象属性排序
List<User> users = getUsers();
List<User> sortedByAge = users.stream()
.sorted(Comparator.comparing(User::getAge))
.collect(Collectors.toList());
// 多字段排序
List<User> sortedMulti = users.stream()
.sorted(Comparator.comparing(User::getAge)
.thenComparing(User::getName))
.collect(Collectors.toList());
4. 聚合操作（取最大、最小、求和等）
List<Integer> nums = Arrays.asList(3, 1, 4, 1, 5, 9);
// 求和
int sum = nums.stream()
.mapToInt(Integer::intValue)
.sum(); // 23
// 取最大值
Optional<Integer> max = nums.stream()
.max(Integer::compareTo); // Optional[9]
// 取最小值
Optional<Integer> min = nums.stream()
.min(Integer::compareTo); // Optional[1]
// 平均值
double avg = nums.stream()
.mapToDouble(Integer::doubleValue)
.average()
.orElse(0.0); // 3.83
// 统计汇总
IntSummaryStatistics stats = nums.stream()
.mapToInt(Integer::intValue)
.summaryStatistics();
// stats.getCount(), stats.getSum(), stats.getMin(), stats.getMax(), stats.getAverage()
// 自定义reduce
Optional<Integer> product = nums.stream()
.reduce((a, b) -> a * b); // 所有数相乘
5. 集合操作（交集、并集、差集）
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4));
Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5, 6));
// 交集
Set<Integer> intersection = set1.stream()
.filter(set2::contains)
.collect(Collectors.toSet()); // [3, 4]
// 并集
Set<Integer> union = new HashSet<>(set1);
union.addAll(set2); // [1, 2, 3, 4, 5, 6]
// 差集（set1有但set2没有）
Set<Integer> difference = set1.stream()
.filter(n -> !set2.contains(n))
.collect(Collectors.toSet()); // [1, 2]
// 对称差集（只在其中一个集合的元素）
Set<Integer> disjunctive = set1.stream()
.filter(n -> !set2.contains(n))
.collect(Collectors.toSet());
set2.stream()
.filter(n -> !set1.contains(n))
.forEach(disjunctive::add); // [1, 2, 5, 6]
6. 分组操作
List<User> users = getUsers();
// 按单个字段分组
Map<String, List<User>> groupedByCity = users.stream()
.collect(Collectors.groupingBy(User::getCity));
// 按条件分组
Map<String, List<User>> groupedByAgeRange = users.stream()
.collect(Collectors.groupingBy(u ->
u.getAge() > 30 ? "中年" : "青年"
));
// 多级分组
Map<String, Map<String, List<User>>> multiGroup = users.stream()
.collect(Collectors.groupingBy(User::getCity,
Collectors.groupingBy(User::getGender)));
// 分组并统计数量
Map<String, Long> countByCity = users.stream()
.collect(Collectors.groupingBy(User::getCity,
Collectors.counting()));
// 分组并求和
Map<String, Integer> sumAgeByCity = users.stream()
.collect(Collectors.groupingBy(User::getCity,
Collectors.summingInt(User::getAge)));
// 分组并取最大
Map<String, Optional<User>> maxAgeByCity = users.stream()
.collect(Collectors.groupingBy(User::getCity,
Collectors.maxBy(Comparator.comparing(User::getAge))));
7. 分区操作
// 按布尔条件分区（只能分为两组）
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6);
Map<Boolean, List<Integer>> partitioned = nums.stream()
.collect(Collectors.partitioningBy(n -> n % 2 == 0));
// {false=[1, 3, 5], true=[2, 4, 6]}
8. 匹配操作
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
// 是否全部匹配
boolean allEven = nums.stream()
.allMatch(n -> n % 2 == 0); // false
// 是否有任意匹配
boolean anyEven = nums.stream()
.anyMatch(n -> n % 2 == 0); // true
// 是否全部不匹配
boolean noneMatch = nums.stream()
.noneMatch(n -> n > 10); // true
9. 查找操作
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
// 查找第一个
Optional<Integer> first = nums.stream()
.findFirst(); // Optional[1]
// 查找任意一个（并行流时更高效）
Optional<Integer> any = nums.stream()
.findAny(); // Optional[1]
// 配合过滤查找第一个匹配
Optional<Integer> firstEven = nums.stream()
.filter(n -> n % 2 == 0)
.findFirst(); // Optional[2]
10. 其他实用操作
List<String> strings = Arrays.asList("a", "b", "c", "d");
// 字符串拼接
String joined = strings.stream()
.collect(Collectors.joining(", ")); // "a, b, c, d"
// 转Map
Map<Integer, String> idToNameMap = users.stream()
.collect(Collectors.toMap(User::getId, User::getName));
// 处理Map的Entry
Map<String, Integer> map = new HashMap<>();
map.entrySet().stream()
.filter(entry -> entry.getValue() > 10)
.forEach(System.out::println);
// 去重并保持顺序
List<Integer> withDups = Arrays.asList(1, 2, 2, 3, 3, 3);
List<Integer> distinctOrdered = withDups.stream()
.distinct()
.collect(Collectors.toList()); // [1, 2, 3]
// 自定义收集器（如果需要）
Collector<Integer, ?, List<Integer>> customCollector =
Collectors.toCollection(LinkedList::new);
性能提示
大数据量：考虑使用并行流 .parallelStream()
原始类型：使用 IntStream, LongStream, DoubleStream 避免装箱开销
提前过滤：先过滤减少后续操作的数据量
避免多次遍历：尽量在一次流操作中完成所有处理
传统方式 vs Stream API
// 传统for循环
List<Integer> result = new ArrayList<>();
for (Integer n : numbers) {
if (n > 3) {
result.add(n * 2);
}
}
// Stream方式（更简洁）
List<Integer> result = numbers.stream()
.filter(n -> n > 3)
.map(n -> n * 2)
.collect(Collectors.toList());