Store all values of Duplicate Key in Map

That doesn’t work in this way. Map keys are unique by definition. You will need a Map<String, List<Integer>> Of course before you add a key you need to lookup if an entry already exists. If not, add a new Arraylist using the key, and add the value to the new list.

Or a much mature alternative could be Guava's multiMap.

You can find the reference to it's usage here

Hope it helps!

Try this and hope it helps.

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

public class MapwithDupKeys {

    public static void main(String[] args) {

        Map<String, List<Integer>> myMultiMap = new HashMap<>();
        add(myMultiMap, "A", 1);
        add(myMultiMap, "A", 2);
        add(myMultiMap, "A", 3);
        add(myMultiMap, "B", 4);
        System.out.println(myMultiMap);
    }

    static void add(Map<String, List<Integer>> map, String key, Integer value) {
        if (map.get(key) == null) {
            List valueList = new ArrayList();
            valueList.add(value);
            map.put(key, valueList);
        } else
            ((ArrayList) map.get(key)).add(value);
    }

}

Lets analyze the requirement

1. You have a key of type String which is needed to map with a collection(unique) of values of type Integer. (unique is my assumption). I mean ("xyz", 1) and ("xyz,1) in case of these two entries in the map it has to be seen as only one entry.
2. From point 1 we can define a structure for an entry : [ Key- String , Value- Set ]
3. A map is needed to hold entries of type as mentioned in point 2.

We can have a map like below.

HashMap <String, Set<Integer>> 

Lets translate it to easiest implementation, although there may be other options too.

  private Map<String, Set<Integer>> map = new HashMap<>();

  public void putPair( String key, Integer value){
          Set<Integer> values = map.get(key);
          if(values == null){
               values = new HashSet<Integer>();
                map.put(key, values);
          }
          values.add(value);
   }

In case multiple same values also you want you can use simple ArrayList instead of Set. But this case better way is to encapsulate the Integer in another wrapper class and keep a count. increment the count in case of same entry.

As per your requirements, you don't need a Map<String, Integer>, but a Map<String, List<Integer>> instead. In other words, you're after a multimap.

One way to achieve such data structure in Java 8+, is by using the Map.computeIfAbsent and Map.computeIfPresent methods for insertions and removals, respectively:

Map<String, List<Integer>> map = new HashMap<>(); // use diamond operator

// INSERT
map.computeIfAbsent("A", k -> new ArrayList<>()).add(1);
map.computeIfAbsent("A", k -> new ArrayList<>()).add(2);
map.computeIfAbsent("A", k -> new ArrayList<>()).add(3);
map.computeIfAbsent("B", k -> new ArrayList<>()).add(4);

// REMOVE
map.computeIfPresent("A", (k, v) -> {
    v.remove(1);
    return v.isEmpty() ? null : v;
});
map.computeIfPresent("A", (k, v) -> {
    v.remove(2);
    return v.isEmpty() ? null : v;
});
map.computeIfPresent("A", (k, v) -> {
    v.remove(3);
    return v.isEmpty() ? null : v;
});
map.computeIfPresent("B", (k, v) -> {
    v.remove(4);
    return v.isEmpty() ? null : v;
});

EDIT:

The remapping function argument for the removals could be extarcted out to the following utility method:

static <K, V> BiFunction<K, List<V>> removing(V elem) {
    return (k, v) -> { v.remove(elem); return v.isEmpty() ? null : v; };
}

Which could then be used as follows:

map.computeIfPresent("A", removing(1));
map.computeIfPresent("A", removing(2));
map.computeIfPresent("A", removing(3));
map.computeIfPresent("B", removing(4));