У меня есть два объекта HashMap, определенные следующим образом:
HashMap<String, Integer> map1 = new HashMap<String, Integer>();
HashMap<String, Integer> map2 = new HashMap<String, Integer>();
У меня также есть третий объект HashMap:
HashMap<String, Integer> map3;
Как объединить map1 и map2 вместе в map3?
map3 = new HashMap<>();
map3.putAll(map1);
map3.putAll(map2);
Если вы знаете, что у вас нет дубликатов ключей, или вы хотите, чтобы значения в map2 перезаписывали значения из map1 для дубликатов ключей, вы можете просто написать
map3 = new HashMap<>(map1);
map3.putAll(map2);
Если вам нужно больше контролировать, как сочетаются значения, вы можете использовать Map.merge, добавленный в Java 8, при условии BiFunction для объединения значений для дубликатов ключей. merge работает с отдельными ключами и значениями, поэтому вам нужно использовать цикл или Map.forEach. Здесь мы объединяем строки для дубликатов ключей:
map3 = new HashMap<>(map1);
for (Map.Entry<String, String> e : map2.entrySet())
map3.merge(e.getKey(), e.getValue(), String::concat);
//or instead of the above loop
map2.forEach((k, v) -> map3.merge(k, v, String::concat));
Если вы знаете, что у вас нет дубликатов ключей и вы хотите принудительно выполнить его, вы можете использовать функцию слияния, которая выдает AssertionError:
map2.forEach((k, v) ->
map3.merge(k, v, (v1, v2) ->
{throw new AssertionError("duplicate values for key: "+k);}));
Сделав шаг назад по этому конкретному вопросу, библиотека потоков Java 8 предоставляет toMap и groupingBy Collectors. Если вы повторно объединяете карты в цикле, вы можете реструктурировать свои вычисления для использования потоков, которые могут как прояснить ваш код, так и упростить использование parallelism с помощью параллельного потока и параллельного коллектора.
One-liner с использованием Java 8 Stream API:
map3 = Stream.of(map1, map2).flatMap(m -> m.entrySet().stream())
.collect(Collectors.toMap(Entry::getKey, Entry::getValue))
Среди преимуществ этого метода - способность передавать функцию слияния, которая будет обрабатывать значения, имеющие один и тот же ключ, например:
map3 = Stream.of(map1, map2).flatMap(m -> m.entrySet().stream())
.collect(Collectors.toMap(Entry::getKey, Entry::getValue, Math::max))
Java 8 альтернативный однострочный для объединения двух карт:
defaultMap.forEach((k, v) -> destMap.putIfAbsent(k, v));
То же самое со ссылкой на метод:
defaultMap.forEach(destMap::putIfAbsent);
Или идемпонент для решения оригинальной карты с третьей картой:
Map<String, Integer> map3 = new HashMap<String, Integer>(map2);
map1.forEach(map3::putIfAbsent);
И вот способ объединить две карты в быструю неизменяемую с Гуавой, которая выполняет наименьшие возможные промежуточные операции копирования:
ImmutableMap.Builder<String, Integer> builder = ImmutableMap.<String, Integer>builder();
builder.putAll(map1);
map2.forEach((k, v) -> {if (!map1.containsKey(k)) builder.put(k, v);});
ImmutableMap<String, Integer> map3 = builder.build();
См. Также Объединение двух карт с Java 8 для случаев, когда значения, присутствующие в обеих картах, должны быть объединены с функцией отображения.
Если вам не нужна изменчивость для вашей окончательной карты, Guava ImmutableMap с его Builder и putAll метод, который, в отличие от Java Map метод интерфейса, можно связать.
Пример использования:
Map<String, Integer> mergeMyTwoMaps(Map<String, Integer> map1, Map<String, Integer> map2) {
return ImmutableMap.<String, Integer>builder()
.putAll(map1)
.putAll(map2)
.build();
}
Конечно, этот метод может быть более общим, использовать varargs и loop to putAll Maps из аргументов и т.д., но я хотел показать концепцию.
Кроме того, ImmutableMap и его Builder имеют мало ограничений (или, может быть, функций?):
NullPointerException - если любой ключ или значение на карте равно нулю)IllegalArgumentException, если добавлены дублирующиеся ключи).У HashMap есть метод putAll.
http://download.oracle.com/javase/6/docs/api/java/util/HashMap.html
Вы можете использовать Collection.addAll() для других типов, например. List, Set и т.д. Для Map вы можете использовать putAll.
Общее решение для объединения двух карт, которые могут совместно использовать общие ключи:
В месте
public static <K, V> void mergeInPlace(Map<K, V> map1, Map<K, V> map2,
BinaryOperator<V> combiner) {
map2.forEach((k, v) -> map1.merge(k, v, combiner::apply));
}
Возврат новой карты:
public static <K, V> Map<K, V> merge(Map<K, V> map1, Map<K, V> map2,
BinaryOperator<V> combiner) {
Map<K, V> map3 = new HashMap<>(map1);
map2.forEach((k, v) -> map3.merge(k, v, combiner::apply));
return map3;
}
Небольшой фрагмент, который я очень часто использую для создания карты из других карт:
static public <K, V> Map<K, V> merge(Map<K, V>... args) {
final Map<K, V> buffer = new HashMap<>();
for (Map m : args) {
buffer.putAll(m);
}
return buffer;
}
Вы можете использовать HashMap<String, List<Integer>> чтобы объединить обе хеш-карты и избежать потери элементов в паре с одним и тем же ключом.
HashMap<String, Integer> map1 = new HashMap<>();
HashMap<String, Integer> map2 = new HashMap<>();
map1.put("key1", 1);
map1.put("key2", 2);
map1.put("key3", 3);
map2.put("key1", 4);
map2.put("key2", 5);
map2.put("key3", 6);
HashMap<String, List<Integer>> map3 = new HashMap<>();
map1.forEach((str, num) -> map3.put(str, new ArrayList<>(Arrays.asList(num))));
//checking for each key if its already in the map, and if so, you just add the integer to the list paired with this key
for (Map.Entry<String, Integer> entry : map2.entrySet()) {
Integer value = entry.getValue();
String key = entry.getKey();
if (map3.containsKey(key)) {
map3.get(key).add(value);
} else {
map3.put(key, new ArrayList<>(Arrays.asList(value)));
}
}
map3.forEach((str, list) -> System.out.println("{" + str + ": " + list + "}"));
выход:
{key1: [1, 4]}
{key2: [2, 5]}
{key3: [3, 6]}
Очень поздно, но позвольте мне поделиться тем, что я сделал, когда у меня была такая же проблема.
Map<String, List<String>> map1 = new HashMap<>();
map1.put("India", Arrays.asList("Virat", "Mahi", "Rohit"));
map1.put("NZ", Arrays.asList("P1","P2","P3"));
Map<String, List<String>> map2 = new HashMap<>();
map2.put("India", Arrays.asList("Virat", "Mahi", "Rohit"));
map2.put("NZ", Arrays.asList("P1","P2","P4"));
Map<String, List<String>> collect4 = Stream.of(map1, map2)
.flatMap(map -> map.entrySet().stream())
.collect(
Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue,
(strings, strings2) -> {
List<String> newList = new ArrayList<>();
newList.addAll(strings);
newList.addAll(strings2);
return newList;
}
)
);
collect4.forEach((s, strings) -> System.out.println(s+"->"+strings));
Это дает следующий вывод
NZ->[P1, P2, P3, P1, P2, P4]
India->[Virat, Mahi, Rohit, Virat, Mahi, Rohit]
Если вы хотите сохранить третью карту так, чтобы изменения, внесенные в любую из записей, не отражались на других картах.
HashMap<String, Integer> map3 = new HashMap<String, Integer>();
map3.putAll(map1);
map3.putAll(map2);
HashMap<String, Integer> map1 = new HashMap<String, Integer>();
HashMap<String, Integer> map2 = new HashMap<String, Integer>();
HashMap<String, Integer> map3 = new HashMap<String, Integer>();
map3.putAll(map1);
map3.putAll(map2);
HashMap<Integer,String> hs1 = new HashMap<>();
hs1.put(1,"ram");
hs1.put(2,"sita");
hs1.put(3,"laxman");
hs1.put(4,"hanuman");
hs1.put(5,"geeta");
HashMap<Integer,String> hs2 = new HashMap<>();
hs2.put(5,"rat");
hs2.put(6,"lion");
hs2.put(7,"tiger");
hs2.put(8,"fish");
hs2.put(9,"hen");
HashMap<Integer,String> hs3 = new HashMap<>();//Map is which we add
hs3.putAll(hs1);
hs3.putAll(hs2);
System.out.println(" hs1 : " + hs1);
System.out.println(" hs2 : " + hs2);
System.out.println(" hs3 : " + hs3);
Повторяющиеся элементы не будут добавлены (то есть дубликаты ключей), так как при печати hs3 мы получим только одно значение для ключа 5, которое будет последним добавленным значением, и это будет крыса. ** [Set имеет свойство не разрешать дубликат ключа, но значения могут быть дублированы]
Способ 1. Поместите карты в список, а затем присоединитесь к
public class Test15 {
public static void main(String[] args) {
Map<String, List<String>> map1 = new HashMap<>();
map1.put("London", Arrays.asList("A", "B", "C"));
map1.put("Wales", Arrays.asList("P1", "P2", "P3"));
Map<String, List<String>> map2 = new HashMap<>();
map2.put("Calcutta", Arrays.asList("Protijayi", "Gina", "Gini"));
map2.put("London", Arrays.asList( "P4", "P5", "P6"));
map2.put("Wales", Arrays.asList( "P111", "P5555", "P677666"));
System.out.println(map1);System.out.println(map2);
// put the maps in an ArrayList
List<Map<String, List<String>>> maplist = new ArrayList<Map<String,List<String>>>();
maplist.add(map1);
maplist.add(map2);
/*
<T,K,U> Collector<T,?,Map<K,U>> toMap(
Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper,
BinaryOperator<U> mergeFunction)
*/
Map<String, List<String>> collect = maplist.stream()
.flatMap(ch -> ch.entrySet().stream())
.collect(
Collectors.toMap(
//keyMapper,
Entry::getKey,
//valueMapper
Entry::getValue,
// mergeFunction
(list_a,list_b) -> Stream.concat(list_a.stream(), list_b.stream()).collect(Collectors.toList())
));
System.out.println("Final Result(Map after join) => " + collect);
/*
{Wales=[P1, P2, P3], London=[A, B, C]}
{Calcutta=[Protijayi, Gina, Gini], Wales=[P111, P5555, P677666], London=[P4, P5, P6]}
Final Result(Map after join) => {Calcutta=[Protijayi, Gina, Gini], Wales=[P1, P2, P3, P111, P5555, P677666], London=[A, B, C, P4, P5, P6]}
*/
}//main
}
Метод 2: объединение карты нормалей
public class Test15 {
public static void main(String[] args) {
Map<String, List<String>> map1 = new HashMap<>();
map1.put("London", Arrays.asList("A", "B", "C"));
map1.put("Wales", Arrays.asList("P1", "P2", "P3"));
Map<String, List<String>> map2 = new HashMap<>();
map2.put("Calcutta", Arrays.asList("Protijayi", "Gina", "Gini"));
map2.put("London", Arrays.asList( "P4", "P5", "P6"));
map2.put("Wales", Arrays.asList( "P111", "P5555", "P677666"));
System.out.println(map1);System.out.println(map2);
/*
<T,K,U> Collector<T,?,Map<K,U>> toMap(
Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper,
BinaryOperator<U> mergeFunction)
*/
Map<String, List<String>> collect = Stream.of(map1,map2)
.flatMap(ch -> ch.entrySet().stream())
.collect(
Collectors.toMap(
//keyMapper,
Entry::getKey,
//valueMapper
Entry::getValue,
// mergeFunction
(list_a,list_b) -> Stream.concat(list_a.stream(), list_b.stream()).collect(Collectors.toList())
));
System.out.println("Final Result(Map after join) => " + collect);
/*
{Wales=[P1, P2, P3], London=[A, B, C]}
{Calcutta=[Protijayi, Gina, Gini], Wales=[P111, P5555, P677666], London=[P4, P5, P6]}
Final Result(Map after join) => {Calcutta=[Protijayi, Gina, Gini], Wales=[P1, P2, P3, P111, P5555, P677666], London=[A, B, C, P4, P5, P6]}
*/
}//main
}
Вы можете использовать функцию putAll для Map, как описано в приведенном ниже коде
HashMap<String, Integer> map1 = new HashMap<String, Integer>();
map1.put("a", 1);
map1.put("b", 2);
map1.put("c", 3);
HashMap<String, Integer> map2 = new HashMap<String, Integer>();
map1.put("aa", 11);
map1.put("bb", 12);
HashMap<String, Integer> map3 = new HashMap<String, Integer>();
map3.putAll(map1);
map3.putAll(map2);
map3.keySet().stream().forEach(System.out::println);
map3.values().stream().forEach(System.out::println);
вы можете использовать метод addAll
http://download.oracle.com/javase/6/docs/api/java/util/HashMap.html
Но всегда есть эта проблема: если ваши два хэш-карты имеют любой ключ, то это переопределит значение ключа из первой хэш-карты со значением ключа из второй карты хэша.
Для более безопасной стороны - измените значения ключа - вы можете использовать префикс или суффикс на клавишах - (другой префикс/суффикс для первой хэш-карты и другой префикс/суффикс для второй карты хэша)