Java 在映射中存储重复键的所有值 Map Map=newhashmap（）； 地图放置（“A”，1）； 地图放置（“A”，2）； 地图放置（“A”，3）； 地图.put(B,4);；

这里我的键是A，它将覆盖A的先前值，并给出键A的值是3。但是我想像存储1、2和3一样存储该键的所有值。然后请告诉我如何将特定键的所有值存储在arraylist中。

这不是以这种方式工作的。映射键根据定义是唯一的。 你需要一个

Map

---

当然，在添加密钥之前，您需要查找条目是否已经存在。如果没有，请使用键添加一个新的Arraylist，并将值添加到新列表中。

或者一个更成熟的替代方法可以是Guava的

multiMap

你可以找到它的用法的参考

---

希望有帮助

让我们分析需求

您有一个

String

类型的键，需要它与

Integer

类型的值集合（唯一）进行映射。（这是我的假设）。我的意思是（“xyz”，1）和（“xyz，1”）如果地图中有这两个条目，那么它只能被视为一个条目

从第1点开始，我们可以定义一个条目的结构：[键-字符串，值-集]

需要一个映射来保存第2点中提到的类型的条目

我们可以有下面这样的地图

Map<String,Integer> map=new HashMap<String,Integer>();
map.put("A",1);
map.put("A",2);
map.put("A",3);
map.put("B",4);

HashMap

让我们将其转换为最简单的实现，尽管可能还有其他选项

HashMap <String, Set<Integer>> 

private Map=new HashMap（）；
公共void putPair（字符串键，整数值）{
设置值=map.get（键）；
如果（值==null）{
值=新的HashSet（）；
map.put（键、值）；
}
增加（价值）；
}

---

如果您还需要多个相同的值，可以使用简单的ArrayList而不是Set。但这种情况下更好的方法是将整数封装在另一个包装类中并保留一个计数。如果是相同的条目，则增加计数。

尝试一下，希望有帮助

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

import java.util.ArrayList；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
公共类MapWithDupKey{
公共静态void main（字符串[]args）{
Map myMultiMap=newhashmap（）；
添加（myMultiMap，“A”，1）；
添加（myMultiMap，“A”，2）；
添加（myMultiMap，“A”，3）；
添加（myMultiMap，“B”，4）；
System.out.println（myMultiMap）；
}
静态void add（映射映射、字符串键、整数值）{
if（map.get（key）==null）{
List valueList=新的ArrayList（）；
价值清单。添加（价值）；
地图放置（键、值列表）；
}否则
（（ArrayList）map.get（key））.add（value）；
}
}

---

根据您的要求，您不需要

地图

，而需要

地图

。换句话说，您需要的是多重地图

在Java 8+中实现这种数据结构的一种方法是分别使用和方法进行插入和删除：

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

}

---

你看了试过吗？

HashMap

@Nitish Tiwari还有什么需要帮助的吗。你的问题有答案（包括我的答案）。请参考它们，如果某些内容仍然不清楚，请更新注释中相应的答案。您也可以更新您的问题。如果您找到解决方案，则您可以接受以最佳方式解决问题的答案尝试

add（myMultiMap，“A”，3）；

然后是

add（myMultiMap，“A”，3）；

，您将添加重复的条目。OP问题是允许同一个键有多个值，最终使键成为重复的，但如果看到一个条目，它总是唯一的。

add（myMultiMap，“A”，3）；

后跟

add（myMultiMap，“A”，4）；

是有效的2个条目，但如果两次添加的数字相同，则应将其视为单个条目

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

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

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