How can I combine two HashMap objects containing the same types?

JavaHashmap

Java Problem Overview

I have two HashMap objects defined like so:

HashMap<String, Integer> map1 = new HashMap<String, Integer>();
HashMap<String, Integer> map2 = new HashMap<String, Integer>();

I also have a third HashMap object:

HashMap<String, Integer> map3;

How can I merge map1 and map2 together into map3?

Java Solutions

Solution 1 - Java

map3 = new HashMap<>();

map3.putAll(map1);
map3.putAll(map2);

Solution 2 - Java

If you know you don't have duplicate keys, or you want values in map2 to overwrite values from map1 for duplicate keys, you can just write

map3 = new HashMap<>(map1);
map3.putAll(map2);

If you need more control over how values are combined, you can use Map.merge, added in Java 8, which uses a user-provided BiFunction to merge values for duplicate keys. merge operates on individual keys and values, so you'll need to use a loop or Map.forEach. Here we concatenate strings for duplicate keys:

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

If you know you don't have duplicate keys and want to enforce it, you can use a merge function that throws an AssertionError:

map2.forEach((k, v) ->
    map3.merge(k, v, (v1, v2) ->
        {throw new AssertionError("duplicate values for key: "+k);}));

Taking a step back from this specific question, the Java 8 streams library provides toMap and groupingBy Collectors. If you're repeatedly merging maps in a loop, you may be able to restructure your computation to use streams, which can both clarify your code and enable easy parallelism using a parallel stream and concurrent collector.

Solution 3 - Java

One-liner using Java 8 Stream API:

map3 = Stream.of(map1, map2).flatMap(m -> m.entrySet().stream())
       .collect(Collectors.toMap(Entry::getKey, Entry::getValue))

Among the benefits of this method is ability to pass a merge function, which will deal with values that have the same key, for example:

map3 = Stream.of(map1, map2).flatMap(m -> m.entrySet().stream())
       .collect(Collectors.toMap(Entry::getKey, Entry::getValue, Math::max))

Solution 4 - Java

Java 8 alternative one-liner for merging two maps:

defaultMap.forEach((k, v) -> destMap.putIfAbsent(k, v));

The same with method reference:

defaultMap.forEach(destMap::putIfAbsent);

Or idemponent for original maps solution with third map:

Map<String, Integer> map3 = new HashMap<String, Integer>(map2);
map1.forEach(map3::putIfAbsent);

And here is a way to merge two maps into fast immutable one with Guava that does least possible intermediate copy operations:

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

See also https://stackoverflow.com/questions/40158605/merge-two-maps-with-java-8 for cases when values present in both maps need to be combined with mapping function.

Solution 5 - Java

If you don't need mutability for your final map, there is Guava's ImmutableMap with its Builder and putAll method which, in contrast to Java's Map interface method, can be chained.

Example of use:

Map<String, Integer> mergeMyTwoMaps(Map<String, Integer> map1, Map<String, Integer> map2) {
  return ImmutableMap.<String, Integer>builder()
      .putAll(map1)
      .putAll(map2)
      .build();
}

Of course, this method can be more generic, use varargs and loop to putAll Maps from arguments etc. but I wanted to show a concept.

Also, ImmutableMap and its Builder have few limitations (or maybe features?):

  • they are null hostile (throw NullPointerException - if any key or value in map is null)
  • Builder don't accept duplicate keys (throws IllegalArgumentException if duplicate keys were added).

Solution 6 - Java

HashMap has a putAll method.

http://download.oracle.com/javase/6/docs/api/java/util/HashMap.html

Solution 7 - Java

You could use Collection.addAll() for other types, e.g. List, Set, etc. For Map, you can use putAll.

Solution 8 - Java

Generic solution for combining two maps which can possibly share common keys:

In-place:

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

Returning a new map:

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

Solution 9 - Java

Very late but let me share what I did when I had the same issue.

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

It gives the following output

NZ->[P1, P2, P3, P1, P2, P4]
India->[Virat, Mahi, Rohit, Virat, Mahi, Rohit]

Solution 10 - Java

A small snippet I use very often to create map from other maps:

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

Solution 11 - Java

you can use HashMap<String, List<Integer>> to merge both hashmaps and avoid losing elements paired with the same key.

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 + "}"));

output:

{key1: [1, 4]}
{key2: [2, 5]}
{key3: [3, 6]}

Solution 12 - Java

You can use putAll function for Map as explained in the code below

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

Solution 13 - Java

Below snippet takes more than one map and combine them.

 private static <K, V> Map<K, V> combineMaps(Map<K, V>... maps) {
    	if (maps == null || maps.length == 0) {
    		return Collections.EMPTY_MAP;
    	}
    
    	Map<K, V> result = new HashMap<>();
    
    	for (Map<K, V> map : maps) {
    		result.putAll(map);
    	}
    	return result;
    }

Demo example link.

Solution 14 - Java

Assuming the following input:

    import java.util.stream.Stream;
    import java.util.stream.Collectors;
    import java.util.Map;
   
    ...

    var m1 = Map.of("k1", 1, "k2", 2);
    var m2 = Map.of("k3", 3, "k4", 4);

When you're sure not to have any key collisions between both input maps, a simple expression that avoids any mutations and yields an immutable result could be:

    var merged = Stream.concat(
        m1.entrySet().stream(),
        m2.entrySet().stream()
    ).collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, Map.Entry::getValue));

In case key collisions are possible, we can provide a lambda to specify how to de-duplicate them. For example if we'd like to keep the largest value in case an entry is present in both input, we could:

    .collect(Collectors.toUnmodifiableMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        Math::max))  // any function  (Integer, Integer) -> Integer  is ok here

Solution 15 - Java

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

Duplicate items will not be added(that is duplicate keys) as when we will print hs3 we will get only one value for key 5 which will be last value added and it will be rat. **[Set has a property of not allowing the duplicate key but values can be duplicate]

Solution 16 - Java

Method 1: Put maps in a List and then join

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


}

Method 2 : Normal Map merge

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


}

In Python, HashMap is called Dictionary and we can merge them very easily.

x = {'Roopa': 1, 'Tabu': 2}
y = {'Roopi': 3, 'Soudipta': 4}


z = {**x,**y}
print(z)

{'Roopa': 1, 'Tabu': 2, 'Roopi': 3, 'Soudipta': 4}

Solution 17 - Java

you can use - addAll method

http://download.oracle.com/javase/6/docs/api/java/util/HashMap.html

But there is always this issue that - if your two hash maps have any key same - then it will override the value of the key from first hash map with the value of the key from second hash map.

For being on safer side - change the key values - you can use prefix or suffix on the keys - ( different prefix/suffix for first hash map and different prefix/suffix for second hash map )

Categories
Recommended Java Solutions
Recommended Hashmap Solutions

Previous Solution:

How can I capture the right-click event in JavaScript?

JavascriptHtmlEventsEvent HandlingDom Events

Next Solution:

Counting Chars in EditText Changed Listener

AndroidListenerAndroid EdittextOnchange

Attributions

All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionMavinView Question on Stackoverflow
Solution 1 - Javaa_horse_with_no_nameView Answer on Stackoverflow
Solution 2 - JavaJeffrey BosboomView Answer on Stackoverflow
Solution 3 - JavaVitalii FedorenkoView Answer on Stackoverflow
Solution 4 - JavaVadzimView Answer on Stackoverflow
Solution 5 - JavaXaerxessView Answer on Stackoverflow
Solution 6 - JavahvgotcodesView Answer on Stackoverflow
Solution 7 - JavafastcodejavaView Answer on Stackoverflow
Solution 8 - JavaZhekaKozlovView Answer on Stackoverflow
Solution 9 - JavaIshan BhattView Answer on Stackoverflow
Solution 10 - JavaThomas DecauxView Answer on Stackoverflow
Solution 11 - JavaOmer VishlitzkyView Answer on Stackoverflow
Solution 12 - JavaP MittalView Answer on Stackoverflow
Solution 13 - JavaHari KrishnaView Answer on Stackoverflow
Solution 14 - JavaSvendView Answer on Stackoverflow
Solution 15 - JavaKaruneshView Answer on Stackoverflow
Solution 16 - JavaSoudipta DuttaView Answer on Stackoverflow
Solution 17 - JavaAshish ShetkarView Answer on Stackoverflow