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);

性能提示

1. 大数据量：考虑使用并行流 .parallelStream()

2. 原始类型：使用 IntStream, LongStream, DoubleStream 避免装箱开销

3. 提前过滤：先过滤减少后续操作的数据量

4. 避免多次遍历：尽量在一次流操作中完成所有处理

传统方式 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());