脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java合并集合方式

Java合并集合几种常见方式总结(List、Set、Map)

 更新时间：2025年03月19日 10:24:47   作者：头孢头孢  
这篇文章主要介绍了Java中合并List、Set、Map的多种方法,包括addAll()、Stream.concat()、Stream.of()+flatMap()、List.copyOf()、putAll()、merge()、compute()和StreamAPI等,文中通过代码介绍的非常详细,需要的朋友可以参考下

Java 提供了多种方式来合并集合（List、Set、Map），不同场景下可选择最合适的方法。以下是常见的合并集合方式的整理：

1. 合并 List

1.1 addAll()

  • 适用场景：直接合并两个 List
  • 特点：修改原集合，无需创建新集合
  • 示例：
List<String> list1 = new ArrayList<>(Arrays.asList("A", "B", "C"));
List<String> list2 = Arrays.asList("D", "E");

list1.addAll(list2);
System.out.println(list1); // [A, B, C, D, E]

1.2 Stream.concat()

  • 适用场景：不修改原集合，返回新 List
  • 特点：流式操作，适用于不可变集合
  • 示例：
List<String> mergedList = Stream.concat(list1.stream(), list2.stream())
                                .collect(Collectors.toList());
System.out.println(mergedList); // [A, B, C, D, E]

1.3 Stream.of() + flatMap()

  • 适用场景：合并多个 List
  • 特点：可同时合并多个 List
  • 示例：
List<String> list3 = Arrays.asList("F", "G");

List<String> mergedList = Stream.of(list1, list2, list3)
                                .flatMap(Collection::stream)
                                .collect(Collectors.toList());

System.out.println(mergedList); // [A, B, C, D, E, F, G]

1.4 List.copyOf()

  • 适用场景：创建不可变 List
  • 特点：返回 不可变 集合
  • 示例：
List<String> mergedList = List.copyOf(Stream.concat(list1.stream(), list2.stream())
                                           .collect(Collectors.toList()));
System.out.println(mergedList); // [A, B, C, D, E]

2. 合并 Set

2.1 addAll()

  • 适用场景：合并 Set（无重复元素）
  • 示例：
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3));
Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5));

set1.addAll(set2);
System.out.println(set1); // [1, 2, 3, 4, 5]

2.2 Stream.concat()

  • 适用场景：不修改原集合
  • 示例：
Set<Integer> mergedSet = Stream.concat(set1.stream(), set2.stream())
                               .collect(Collectors.toSet());
System.out.println(mergedSet); // [1, 2, 3, 4, 5]

2.3 Stream.of() + flatMap()

  • 适用场景：合并多个 Set
  • 示例：
Set<Integer> set3 = new HashSet<>(Arrays.asList(6, 7));

Set<Integer> mergedSet = Stream.of(set1, set2, set3)
                               .flatMap(Set::stream)
                               .collect(Collectors.toSet());

System.out.println(mergedSet); // [1, 2, 3, 4, 5, 6, 7]

3. 合并 Map

3.1 putAll()

  • 适用场景：直接合并 Map
  • 特点：如果 key 存在，后者会覆盖前者
  • 示例：
Map<String, Integer> map1 = new HashMap<>();
map1.put("A", 1);
map1.put("B", 2);

Map<String, Integer> map2 = new HashMap<>();
map2.put("B", 3);
map2.put("C", 4);

map1.putAll(map2);
System.out.println(map1); // {A=1, B=3, C=4}

3.2 merge()

  • 适用场景：合并时处理重复 key
  • 特点：可指定 key 处理方式
  • 示例：
map2.forEach((key, value) ->
    map1.merge(key, value, Integer::sum)
);
System.out.println(map1); // {A=1, B=5, C=4}

3.3 compute()

  • 适用场景：动态计算 key
  • 示例：
map2.forEach((key, value) ->
    map1.compute(key, (k, v) -> (v == null) ? value : v + value)
);
System.out.println(map1); // {A=1, B=5, C=4}

3.4 Stream API

  • 适用场景：不修改原 Map，生成新 Map
  • 示例：
Map<String, Integer> mergedMap = Stream.of(map1, map2)
    .flatMap(m -> m.entrySet().stream())
    .collect(Collectors.toMap(
        Map.Entry::getKey, 
        Map.Entry::getValue, 
        Integer::sum));

System.out.println(mergedMap); // {A=1, B=5, C=4}

4. 总结

数据结构方法适用场景是否修改原集合
ListaddAll()直接合并✅
Stream.concat()不修改原 List❌
Stream.of() + flatMap()合并多个 List❌
List.copyOf()创建不可变 List❌
SetaddAll()直接合并✅
Stream.concat()不修改原 Set❌
Stream.of() + flatMap()合并多个 Set❌
MapputAll()后者覆盖前者✅
merge()合并相同 key✅
compute()计算 key 值✅
Stream API不修改原 Map❌
  • ✅ 修改原集合：适用于直接更新已有集合的场景。
  • ❌ 不修改原集合：适用于函数式编程、不可变集合的场景。

这几种方式适用于不同的开发需求，具体选择哪种方法取决于业务逻辑和性能要求。

到此这篇关于Java合并集合几种常见方式总结(List、Set、Map)的文章就介绍到这了,更多相关Java合并集合方式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

最新评论