Task - Stream API - Merging Maps

[akash-coded]

You have two maps m1 and m2 of type Map<Integer, String>, which have to be merged into a single map of type Map<Integer, List<String>>, where values of the same keys in both the maps are collected into a List and put into a new Map.

Sample map m1

{
    1 = "A",
    2 = "B"
}

Sample map m2

{
    1 = "C",
    2 = "D"
}

Expected Output

{
    1 = [A, C],
    2 = [B, D]
}

Hint

For ideas, you can refer to Java groupingBy collector.

[ratnadeepikavuddagiri]

package JavaCollections.Maps;

import java.util.*;

public class MergeMaps {
    public static void main(String[] args) {
        HashMap<Integer,String> m1 = new HashMap<>();
        HashMap<Integer,String> m2 = new HashMap<>();
        m1.put(1,"A");
        m1.put(2,"B");
        m2.put(1,"C");
        m2.put(2,"D");
        HashMap<Integer,Set<String>> mergeMap = new HashMap<>();
        Iterator<Integer> itr1 = m1.keySet().iterator();
        while (itr1.hasNext()) {
            int key = itr1.next();
            String value = m1.get(key);
            Set<String> set = new HashSet<>(); 
                set.add(value);
                mergeMap.put(key,set);
        }
        Iterator<Integer> itr2 = m2.keySet().iterator();
        while (itr2.hasNext()) {
            int key = itr2.next();
            String value = m2.get(key);
            Set<String> set = new HashSet<>(); 
            if(mergeMap.containsKey(key)){
                set = mergeMap.get(key);
                set.add(value);
                mergeMap.put(key,set);
            }
            else{
                set.add(value);
                mergeMap.put(key,set);
            }
        }
        System.out.println(mergeMap);
    }
}

[rakeshGit419]

import java.util.*;

public class MapDriver{
    public static void main(String[] args){

        Map<Integer, String> map1 = new HashMap<>();
        Map<Integer, String> map2 = new HashMap<>();
        map1.put(1,"A");
        map1.put(2,"B");
        map2.put(1,"C");
        map2.put(2,"D");

        Map<Integer,List<String>> map3 = new HashMap<>();

        map1.forEach((k,v)->map3.put(k,new ArrayList<>(Arrays.asList(v))));
        for(Integer i: map2.keySet()){
            if(map3.containsKey(i)) map3.get(i).add(map2.get(i));
            else map3.put(i, new ArrayList<>(Arrays.asList(map2.get(i))));
        }
        // map3.forEach((k,v)->System.out.println(k+" = "+v));
        System.out.println(map3);
    }
}

[VigneshVishwa]

package collection;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class MergeMaps {
    public static void main(String[] args) {
        Map<Integer, String> m1 = new HashMap<Integer, String>();
        Map<Integer, String> m2 = new HashMap<Integer, String>();
        Map<Integer, List<String>> m = new HashMap<Integer, List<String>>();
        m1.put(1, "A");
        m1.put(2, "B");
        m2.put(1, "C");
        m2.put(2, "D");
        Iterator<Integer> itr = m1.keySet().iterator();
        while (itr.hasNext()) {
            int key = itr.next();
            String value = m1.get(key);
            List<String> list = new ArrayList<String>();
            if (m.containsKey(key)) {
                list = m.get(key);
                list.add(value);
                m.put(key, list);
            } else {
                list.add(value);
                m.put(key, list);
            }
        }
        Iterator<Integer> itr1 = m2.keySet().iterator();
        while (itr1.hasNext()) {
            int key = itr1.next();
            String value = m2.get(key);
            List<String> list = new ArrayList<String>();
            if (m.containsKey(key)) {
                list = m.get(key);
                list.add(value);
                m.put(key, list);
            } else {
                list.add(value);
                m.put(key, list);
            }
        }
        System.out.println(m);

    }
}

[Ashritha-sd]

import java.util.*;
public class MergingMaps{
    public static void main(String[] args){
        Map<Integer, String> m1 = new HashMap<>();
        Map<Integer, String> m2 = new HashMap<>();
        m1.put(1,"A");
        m1.put(2,"B");
        m2.put(1,"C");
        m2.put(2,"D");
        Map<Integer,List<String>> m3 = new HashMap<>();
        for (Map.Entry mapElement : m1.entrySet()) {
            Integer key=(Integer)mapElement.getKey();
            List<String> l=new ArrayList<String>();
            String value1=(String)m1.get(key);
            String value2=(String)m2.get(key);
            //System.out.println(value1+" "+value2);
            l.add(value1);
            l.add(value2);
            //System.out.println(l);
            m3.put(key,l);
            //System.out.println(m3);
            //l.clear();
        }
       System.out.println(m3);
            
    }
}

[sruthi-15-sketch]

public class Main
{
	public static void main(String[] args) {
		HashMap<Integer,ArrayList<String>> h=new HashMap<>();
		HashMap<Integer,String> h1=new HashMap<>();
		h1.put(1,"A");
		h1.put(2,"B");
		//h1.put(4,"F");
		HashMap<Integer,String> h2=new HashMap<>();
		h2.put(1,"C");
		h2.put(2,"D");
		//h2.put(3,"E");
		Iterator<Integer> itr1 = h1.keySet().iterator();
		for(Map.Entry<Integer,String> m:h1.entrySet()){
		    ArrayList<String> l=new ArrayList<>();
		    l.add(m.getValue());
		    h.put(m.getKey(),new ArrayList<String>(l));
		    l.removeAll(l);
		}
		//System.out.println(h);
		for(Map.Entry<Integer,String> m:h2.entrySet()){
		    if (h.containsKey(m.getKey())){
		        ArrayList<String> l1=h.get(m.getKey());
		        l1.add(m.getValue());
		        h.put(m.getKey(),new ArrayList<String>(l1));
		        l1.removeAll(l1);
		    }
		    else{
		    ArrayList<String> l=new ArrayList<>();
		    l.add(m.getValue());
		    h.put(m.getKey(),new ArrayList<String>(l));
		    l.removeAll(l);}
		}
	    System.out.println(h);
	}
}

[SrideviYamala]

package collections;

import java.util.*;

public class MergingMaps {
    public static void main(String[] args) {
        Map<Integer, String> m1 = new HashMap<>();
        Map<Integer, String> m2 = new HashMap<>();
        m1.put(1, "A");
        m1.put(2, "B");
        m2.put(1, "C");
        m2.put(2, "D");
        Map<Integer, List<String>> map = new HashMap<>();
        for(Map.Entry<Integer, String> mapEntry : m1.entrySet()) {
            Integer key = mapEntry.getKey();
            List<String> l = new ArrayList<>();
            l.add(m1.get(key));
            l.add(m2.get(key));
            map.put(key, l);
        }
        System.out.println(map);
    }
}

[Shubhi27]

package maps;

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

public class MergeTwoMaps {
    public static void main(String[] args) {
        Map<Integer, String> map1 = new HashMap<>();
        map1.put(1, "A");
        map1.put(2, "B");

        Map<Integer, String> map2 = new HashMap<>();
        map2.put(1, "C");
        map2.put(2, "D");
        Map<Integer, List<String>> mergedMap = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream())
                .collect(
                        Collectors.groupingBy(Map.Entry::getKey,
                                Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

        System.out.println(mergedMap);

    }
}

[Ashwesh09]

import java.util.*;
import java.util.stream.*;
public class MergerMaps {
    public static void main(String[] args) {
        Map<Integer, String> m1 = new HashMap<>();
        m1.put(1, "A");
        m1.put(2, "B");

        Map<Integer, String> m2 = new HashMap<>();
        m2.put(1, "C");
        m2.put(2, "D");
        Map<Integer, List<String>> mergedMap = Stream.concat(m1.entrySet().stream(), m2.entrySet().stream())
                .collect(
                        Collectors.groupingBy(Map.Entry::getKey,
                                Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

        System.out.println(mergedMap);

    }
}

[lalit-ky]

package collections;

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

public class MergeMaps {
    public static void main(String[] args) {
        Map<Integer, String> m1 = new HashMap<>();
        Map<Integer, String> m2 = new HashMap<>();

        m1.put(1, "A");
        m1.put(2, "B");

        m2.put(1, "C");
        m2.put(2, "D");

        Map<Integer, List<String>> ans = Stream.concat(m1.entrySet().stream(), m2.entrySet().stream()).collect(
                Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
        System.out.println(ans);
    }
}

[Sarfinaa]

package week_5.streams;

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

public class MapTask {
    public static void main(String[] args) {
        // Without using Collections
        Map<Integer, String> map1 = new HashMap<>();
        Map<Integer, String> map2 = new HashMap<>();
        map1.put(1, "A");
        map1.put(2, "B");
        map2.put(1, "C");
        map2.put(2, "D");
        Map<Integer, List<String>> map = new HashMap<>();
        map1.forEach((k, v) -> {
            map.put(k, new ArrayList<>());
            map.get(k).add(v);
        });
        map2.forEach((k, v) -> {
            map.get(k).add(v);
        });
        System.out.println(map);

        // With Collections
        Stream<Map.Entry<Integer, String>> stream = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream());
        Map<Integer, List<String>> streamMap = stream.collect(
                Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
        System.out.println(streamMap);
    }
}

[Krishreddy460]

import java.util.;
import java.util.stream.;
import java.util.stream.collectors.*;

public class Merge {
public static void main(String[] args) {
Map<Integer, String> m1 = new HashMap<Integer,String>();
m1.put(1, "A");
m1.put(2, "B");

    Map<Integer, String> m2 = new HashMap<Integer,String>();
    m2.put(1, "C");
    m2.put(2, "D");
    Map<Integer, List<String>> merge = Stream.concat(m1.entrySet().stream(),m2.entrySet().stream()).collect(Collectors.groupingBy(Map.Entry::getKey,Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

    System.out.println(merge);

}

}

[Snehil6197]

import java.util.List;
import java.util.Map;
import java.util.Collection;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class MergeMaps {

public static void main(String[] args) {
    Map<Integer, String> m1 = new HashMap<>();
    Map<Integer, String> m2 = new HashMap<>();
    List<String> l=new ArrayList<>();

    m1.put(1, "A");
    m1.put(2, "B");

    m2.put(1, "C");
    m2.put(2, "D");

    Stream<Map.Entry<Integer, String>>concatMap=Stream.concat(m1.entrySet().stream(), m2.entrySet().stream());
    
    Map<Integer, List<String>> ans = concatMap.collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

    System.out.println(ans);

}

}
``

[Batchusatyasri]

`package Maps;

import java.util.*;

public class Mapsmerger {
public static void main(String[] args) {
Map<Integer, String> map1 = new HashMap<>();
Map<Integer, String> map2 = new HashMap<>();
map1.put(1, "A");
map1.put(2, "B");
map2.put(1, "C");
map2.put(2, "D");
Map<Integer, List> maps = new HashMap<>();
for (Map.Entry<Integer, String> mapEntry : map1.entrySet()) {
Integer key = mapEntry.getKey();
List l = new ArrayList<>();
l.add(map1.get(key));
l.add(map2.get(key));
maps.put(key, l);
}
System.out.println(maps);
}
}
`

[Khyati-tripathi]

package MapsModule;

import java.util.*;
import java.util.stream.*;

public class MergeMaps {
    public static void main(String[] args) {

        Map<Integer, String> m1 = new HashMap<>();
        Map<Integer, String> m2 = new HashMap<>();
        m1.put(1, "A");
        m1.put(2, "B");
        m2.put(1, "C");
        m2.put(2, "D");
        Map<Integer, List<String>> mergeMap = Stream.concat(m1.entrySet().stream(), m2.entrySet().stream()).collect(
                Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
        System.out.println(mergeMap);
        }

    }
}

[ujjwal18bit1167]

import java.util.*;
public class MergingMaps{
    public static void main(String[] args){
        Map<Integer, String> m1 = new HashMap<>();
        Map<Integer, String> m2 = new HashMap<>();
        m1.put(1,"A");
        m1.put(2,"B");
        m2.put(1,"C");
        m2.put(2,"D");
        Map<Integer,List<String>> m3 = new HashMap<>();
        for (Map.Entry mapElement : m1.entrySet()) {
            Integer key=(Integer)mapElement.getKey();
            List<String> l=new ArrayList<String>();
            String value1=(String)m1.get(key);
            String value2=(String)m2.get(key);
            l.add(value1);
            l.add(value2);
            m3.put(key,l);
            
        }
       System.out.println(m3);
            
    }
}

[RohitN09]

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

public class MergeMaps {
    public static void main(String[] args) {
        Map<Integer, String> map1 = new HashMap<>();
        map1.put(1, "A");
        map1.put(2, "B");

        Map<Integer, String> map2 = new HashMap<>();
        map2.put(1, "C");
        map2.put(2, "D");

        Map<Integer, List<String>> mergedMap = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream())
                .collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));

        System.out.println(mergedMap);

    }
}