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

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. 总结

数据结构	方法	适用场景	是否修改原集合
list	`addall()`	直接合并	✅
	`stream.concat()`	不修改原 list	❌
	`stream.of() + flatmap()`	合并多个 list	❌
	`list.copyof()`	创建不可变 list	❌
set	`addall()`	直接合并	✅
	`stream.concat()`	不修改原 set	❌
	`stream.of() + flatmap()`	合并多个 set	❌
map	`putall()`	后者覆盖前者	✅
	`merge()`	合并相同 key	✅
	`compute()`	计算 key 值	✅
	`stream api`	不修改原 map	❌