blocks|key|77956|text|您可以简单地为常规HashMap中的值传递一个值数组，从而模拟重复的键，并由您决定使用什么数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|77957|您也可以只使用MultiMap，尽管我自己不喜欢重复键的想法。|offset|length|77958|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/tutorial/collections/interfaces/map.html^0|0|7|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

You could simply pass an array of values for the value in a regular HashMap, thus simulating duplicate keys, and it would be up to you to decide what data to use.

You may also just use a <a href="http://java.sun.com/docs/books/tutorial/collections/interfaces/map.html" rel="noreferrer">MultiMap</a>, although I do not like the idea of duplicate keys myself.

blocks|key|1378397|text|您还可以解释一下您正在尝试实现具有重复键的映射的上下文吗？我相信可能会有更好的解决方案。由于很好的理由，映射旨在保持唯一键。但是，如果你真的想这样做，你总是可以扩展这个类，编写一个简单的自定义映射类，它具有冲突缓解功能，并使你能够用相同的键保存多个条目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378398|注意:您必须实现冲突缓解功能，以便将冲突键转换为唯一的set+"always“。一些简单的事情，比如，用对象哈希码或其他东西来追加key？|1378399|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Could you also explain the context for which you are trying to implement a map with duplicate keys? I am sure there could be a better solution. Maps are intended to keep unique keys for good reason. Though if you really wanted to do it; you can always extend the class write a simple custom map class which has a collision mitigation function and would enable you to keep multiple entries with same keys. 

Note: You must implement collision mitigation function such that, colliding keys are converted to unique set "always". Something simple like, appending key with object hashcode or something?

blocks|key|1378444|text|您正在搜索multimap，实际上commons-collections和Guava都有几个实现。多重映射允许通过维护每个键的值集合来支持多个键，例如，您可以将单个对象放入映射中，但您可以检索一个集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378445|如果您可以使用Java5，我更喜欢Guava的Multimap，因为它是泛型感知的。|offset|length|style|CODE|1378446|entityMap|0|LINK|mutability|MUTABLE|url|https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/Multimap.html^0|0|N|8|N|8|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]]|9|@$D|T|E|U|1|V]]|A|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

You are searching for a multimap, and indeed both commons-collections and Guava have several implementations for that. Multimaps allow for multiple keys by maintaining a collection of values per key, i.e. you can put a single object into the map, but you retrieve a collection.

If you can use Java 5, I would prefer Guava's <a href="https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/Multimap.html" rel="noreferrer"><code>Multimap</code></a> as it is generics-aware.

blocks|key|78971|text|如果您希望遍历键值对列表(如您在注释中所写的那样)，那么列表或数组应该更好。首先组合你的键和值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|78972|public+class+Pair
{
+++public+Class1+key;
+++public+Class2+value;

+++public+Pair(Class1+key,+Class2+value)
+++{
++++++this.key+=+key;
++++++this.value+=+value;
+++}

}|code-block|syntax|javascript|78973|将Class1和Class2替换为要用于键和值的类型。|78974|现在，您可以将它们放入数组或列表中，并对它们进行迭代：|78975|Pair[]+pairs+=+new+Pair[10];
...
for+(Pair+pair+:+pairs)
{
+++...
}|78976|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you want iterate about a list of key-value-pairs (as you wrote in the comment), then a List or an array should be better. First combine your keys and values:

<pre><code>public class Pair
{
 public Class1 key;
 public Class2 value;

 public Pair(Class1 key, Class2 value)
 {
 this.key = key;
 this.value = value;
 }

}
</code></pre>

Replace Class1 and Class2 with the types you want to use for keys and values.

Now you can put them into an array or a list and iterate over them:

<pre><code>Pair[] pairs = new Pair[10];
...
for (Pair pair : pairs)
{
 ...
}
</code></pre>

blocks|key|78047|text|完整地说，Apache+Commons+Collections也有一个MultiMap。当然，缺点是Apache+Commons不使用泛型。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|78048|entityMap|0|LINK|mutability|MUTABLE|url|http://commons.apache.org/collections/api-release/org/apache/commons/collections/MultiMap.html^0|Z|8|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

just to be complete, Apache Commons Collections also has a <a href="http://commons.apache.org/collections/api-release/org/apache/commons/collections/MultiMap.html" rel="nofollow noreferrer">MultiMap</a>. The downside of course is that Apache Commons does not use Generics.

blocks|key|4248557|text|如果存在重复的键，则一个键可以对应于多个值。显而易见的解决方案是将键映射到这些值的列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4248558|例如在Python中：|4248559|map+=+dict()
map["driver"]+=+list()
map["driver"].append("john")
map["driver"].append("mike")
print+map["driver"]++++++++++#+It+shows+john+and+mike
print+map["driver"][0]+++++++#+It+shows+john
print+map["driver"][1]+++++++#+It+shows+mike|code-block|syntax|javascript|4248560|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If there are duplicate keys then a key may correspond to more than one value. The obvious solution is to map the key to a list of these values. 

For example in Python:

<pre><code>map = dict()
map["driver"] = list()
map["driver"].append("john")
map["driver"].append("mike")
print map["driver"] # It shows john and mike
print map["driver"][0] # It shows john
print map["driver"][1] # It shows mike
</code></pre>

blocks|key|78092|text|2021年6月|type|unstyled|depth|inlineStyleRanges|entityRanges|data|78093|78094|org.springframework.util.MultiValueMap|ordered-list-item|offset|length|78095|78096|78097|commons.apache.org+-+org.apache.commons.collections4|78098|78099|MultiValueMap类|78100|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/MultiValueMap.html|1|http://commons.apache.org/proper/commons-collections/javadocs/api-4.4/org/apache/commons/collections4/MultiValuedMap.html^0|0|0|0|12|0|0|0|0|0|1G|1|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|10|8|@]|9|@$F|11|G|12|1|13]]|A|$]]|$1|H|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|16|8|@]|9|@$F|17|G|18|1|19]]|A|$]]|$1|L|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

[June, 2021]
<ol>
<li><a href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/MultiValueMap.html" rel="nofollow noreferrer">org.springframework.util.MultiValueMap</a>
</li>
<li><a href="http://commons.apache.org/proper/commons-collections/javadocs/api-4.4/org/apache/commons/collections4/MultiValuedMap.html" rel="nofollow noreferrer">commons.apache.org - org.apache.commons.collections4</a>
</li>
</ol>
MultiValueMap class

blocks|key|1031287|text|我们不需要依赖Google+Collections外部库。您可以简单地实现以下Map：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1031288|Map<String,+ArrayList<String>>+hashMap+=+new+HashMap<String,+ArrayList>();

public+static+void+main(String...+arg)+{
+++//+Add+data+with+duplicate+keys
+++addValues("A",+"a1");
+++addValues("A",+"a2");
+++addValues("B",+"b");
+++//+View+data.
+++Iterator+it+=+hashMap.keySet().iterator();
+++ArrayList+tempList+=+null;

+++while+(it.hasNext())+{
++++++String+key+=+it.next().toString();+++++++++++++
++++++tempList+=+hashMap.get(key);
++++++if+(tempList+!=+null)+{
+++++++++for+(String+value:+tempList)+{
++++++++++++System.out.println("Key+:+"%2Bkey%2B+"+,+Value+:+"%2Bvalue);
+++++++++}
++++++}
+++}
}

private+void+addValues(String+key,+String+value)+{
+++ArrayList+tempList+=+null;
+++if+(hashMap.containsKey(key))+{
++++++tempList+=+hashMap.get(key);
++++++if(tempList+==+null)
+++++++++tempList+=+new+ArrayList();
++++++tempList.add(value);++
+++}+else+{
++++++tempList+=+new+ArrayList();
++++++tempList.add(value);+++++++++++++++
+++}
+++hashMap.put(key,tempList);
}|code-block|syntax|javascript|1031289|请确保对代码进行微调。|1031290|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

We don't need to depend on the Google Collections external library. You can simply implement the following Map:

<pre><code>Map&lt;String, ArrayList&lt;String&gt;&gt; hashMap = new HashMap&lt;String, ArrayList&gt;();

public static void main(String... arg) {
 // Add data with duplicate keys
 addValues("A", "a1");
 addValues("A", "a2");
 addValues("B", "b");
 // View data.
 Iterator it = hashMap.keySet().iterator();
 ArrayList tempList = null;

 while (it.hasNext()) {
 String key = it.next().toString(); 
 tempList = hashMap.get(key);
 if (tempList != null) {
 for (String value: tempList) {
 System.out.println("Key : "+key+ " , Value : "+value);
 }
 }
 }
}

private void addValues(String key, String value) {
 ArrayList tempList = null;
 if (hashMap.containsKey(key)) {
 tempList = hashMap.get(key);
 if(tempList == null)
 tempList = new ArrayList();
 tempList.add(value); 
 } else {
 tempList = new ArrayList();
 tempList.add(value); 
 }
 hashMap.put(key,tempList);
}
</code></pre>

Please make sure to fine tune the code.

blocks|key|1380588|text|向我的mistakes...please学习不要自己实现这一点。芭乐多重映射是一种可行的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1380589|在多映射中需要的一个常见增强是不允许重复的键-值对。|1380590|在你的实现中实现/改变它可能会很烦人。|1380591|在Guava中，它就像这样简单：|1380592|HashMultimap<String,+Integer>+no_dupe_key_plus_val+=+HashMultimap.create();

ArrayListMultimap<String,+Integer>+allow_dupe_key_plus_val+=+ArrayListMultimap.create();|code-block|syntax|javascript|1380593|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Learn from my mistakes...please don't implement this on your own.
Guava multimap is the way to go.

A common enhancement required in multimaps is to disallow duplicate keys-value pairs.

Implementing/changing this in a your implementation can be annoying.

In Guava its as simple as:

<pre><code>HashMultimap&lt;String, Integer&gt; no_dupe_key_plus_val = HashMultimap.create();

ArrayListMultimap&lt;String, Integer&gt; allow_dupe_key_plus_val = ArrayListMultimap.create();
</code></pre>

blocks|key|1378588|text|对于这个问题，我有一个稍微不同的变体:它需要将两个不同的值与相同的键相关联。只是在这里发布它，以防它对其他人有帮助，我引入了一个HashMap作为值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1378589|/*+@param+frameTypeHash:+Key+->+Integer+(frameID),+Value+->+HashMap+(innerMap)
+++@param+innerMap:+Key+->+String+(extIP),+Value+->+String
+++If+the+key+exists,+retrieve+the+stored+HashMap+innerMap+
+++and+put+the+constructed+key,+value+pair
*/
++if+(frameTypeHash.containsKey(frameID)){
++++++++++++//Key+exists,+add+the+key/value+to+innerHashMap
++++++++++++HashMap+innerMap+=+(HashMap)frameTypeHash.get(frameID);
++++++++++++innerMap.put(extIP,+connName%2B":"%2BframeType%2B":"%2BinterfaceName);

++++++++}+else+{
++++++++++++HashMap<String,+String>+innerMap+=+new+HashMap<String,+String>();
++++++++++++innerMap.put(extIP,+connName%2B":"%2BframeType%2B":"%2BinterfaceName);
++++++++++++//+This+means+the+key+doesn't+exists,+adding+it+for+the+first+time
++++++++++++frameTypeHash.put(frameID,+innerMap+);
++++++++}
}|code-block|syntax|javascript|1378590|在上面的代码中，键frameID是从输入文件的每一行的第一个字符串中读取的，frameTypeHash的值是通过拆分剩余的行构造的，最初是作为string对象存储的，在一段时间内，文件开始有多行(具有不同的值)与相同的frameID键相关联，因此frameTypeHash被最后一行作为值覆盖。我将String对象替换为另一个HashMap对象作为值字段，这有助于维护单个键到不同值的映射。|1378591|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I had a slightly different variant of this issue: It was required to associate two different values with same key. Just posting it here in case it helps others, I have introduced a HashMap as the value:

<pre><code>/* @param frameTypeHash: Key -&gt; Integer (frameID), Value -&gt; HashMap (innerMap)
 @param innerMap: Key -&gt; String (extIP), Value -&gt; String
 If the key exists, retrieve the stored HashMap innerMap 
 and put the constructed key, value pair
*/
 if (frameTypeHash.containsKey(frameID)){
 //Key exists, add the key/value to innerHashMap
 HashMap innerMap = (HashMap)frameTypeHash.get(frameID);
 innerMap.put(extIP, connName+":"+frameType+":"+interfaceName);

 } else {
 HashMap&lt;String, String&gt; innerMap = new HashMap&lt;String, String&gt;();
 innerMap.put(extIP, connName+":"+frameType+":"+interfaceName);
 // This means the key doesn't exists, adding it for the first time
 frameTypeHash.put(frameID, innerMap );
 }
}
</code></pre>

In the above code the key frameID is read from a input file's first string in each line, the value for frameTypeHash is constructed by splitting the remaining line and was stored as String object originally, over a period of time the file started having multiple lines (with different values) associated with same frameID key, so frameTypeHash was overwritten with last line as the value. I replaced the String object with another HashMap object as the value field, this helped in maintaining single key to different value mapping.

blocks|key|1380635|text|Multimap<Integer,+String>+multimap+=+ArrayListMultimap.create();

multimap.put(1,+"A");
multimap.put(1,+"B");
multimap.put(1,+"C");
multimap.put(1,+"A");

multimap.put(2,+"A");
multimap.put(2,+"B");
multimap.put(2,+"C");

multimap.put(3,+"A");

System.out.println(multimap.get(1));
System.out.println(multimap.get(2));+++++++
System.out.println(multimap.get(3));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1380636|输出为：|unstyled|1380637|[A,B,C,A]
[A,B,C]
[A]|1380638|注意：我们需要导入库文件。|offset|length|style|BOLD|1380639|http://www.java2s.com/Code/Jar/g/Downloadgooglecollectionsjar.htm|1380640|import+com.google.common.collect.ArrayListMultimap;
import+com.google.common.collect.Multimap;|1380641|或https://commons.apache.org/proper/commons-collections/download_collections.cgi|1380642|import+org.apache.commons.collections.MultiMap;
import+org.apache.commons.collections.map.MultiValueMap;|1380643|entityMap|0|LINK|mutability|MUTABLE|url|1|https://commons.apache.org/proper/commons-collections/download_collections.cgi^0|0|0|0|0|3|0|0|1T|0|0|0|1|26|1|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|17|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|18|8|@$K|19|L|1A|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|1B|8|@]|9|@$K|1C|L|1D|1|1E]]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$B|C]]|$1|S|3|T|5|F|7|1G|8|@]|9|@$K|1H|L|1I|1|1J]]|A|$]]|$1|U|3|V|5|6|7|1K|8|@]|9|@]|A|$B|C]]|$1|W|3|-4|5|F|7|1L|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|P]]|13|$5|Z|10|11|A|$12|14]]]]

<pre><code>Multimap&lt;Integer, String&gt; multimap = ArrayListMultimap.create();

multimap.put(1, "A");
multimap.put(1, "B");
multimap.put(1, "C");
multimap.put(1, "A");

multimap.put(2, "A");
multimap.put(2, "B");
multimap.put(2, "C");

multimap.put(3, "A");

System.out.println(multimap.get(1));
System.out.println(multimap.get(2)); 
System.out.println(multimap.get(3));
</code></pre>

Output is: 

<pre><code>[A,B,C,A]
[A,B,C]
[A]
</code></pre>

Note: we need to import library files.

<a href="http://www.java2s.com/Code/Jar/g/Downloadgooglecollectionsjar.htm" rel="noreferrer">http://www.java2s.com/Code/Jar/g/Downloadgooglecollectionsjar.htm</a>

<pre><code>import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
</code></pre>

or <a href="https://commons.apache.org/proper/commons-collections/download_collections.cgi" rel="noreferrer">https://commons.apache.org/proper/commons-collections/download_collections.cgi</a>

<pre><code>import org.apache.commons.collections.MultiMap;
import org.apache.commons.collections.map.MultiValueMap;
</code></pre>

blocks|key|78183|text|稍加修改，你就可以使用带有重复密钥的HashSet。警告:这很大程度上依赖于HashSet实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|78184|class+MultiKeyPair+{
++++Object+key;
++++Object+value;

++++public+MultiKeyPair(Object+key,+Object+value)+{
++++++++this.key+=+key;
++++++++this.value+=+value;
++++}

++++@Override
++++public+int+hashCode()+{
++++++++return+key.hashCode();
++++}
}

class+MultiKeyList+extends+MultiKeyPair+{
++++ArrayList<MultiKeyPair>+list+=+new+ArrayList<MultiKeyPair>();

++++public+MultiKeyList(Object+key)+{
++++++++super(key,+null);
++++}

++++@Override
++++public+boolean+equals(Object+obj)+{
++++++++list.add((MultiKeyPair)+obj);
++++++++return+false;
++++}
}

public+static+void+main(String[]+args)+{
++++HashSet<MultiKeyPair>+set+=+new+HashSet<MultiKeyPair>();
++++set.add(new+MultiKeyPair("A","a1"));
++++set.add(new+MultiKeyPair("A","a2"));
++++set.add(new+MultiKeyPair("B","b1"));
++++set.add(new+MultiKeyPair("A","a3"));

++++MultiKeyList+o+=+new+MultiKeyList("A");
++++set.contains(o);

++++for+(MultiKeyPair+pair+:+o.list)+{
++++++++System.out.println(pair.value);
++++}
}|code-block|syntax|javascript|78185|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

With a bit hack you can use HashSet with duplicate keys. WARNING: this is heavily HashSet implementation dependant. 

<pre><code>class MultiKeyPair {
 Object key;
 Object value;

 public MultiKeyPair(Object key, Object value) {
 this.key = key;
 this.value = value;
 }

 @Override
 public int hashCode() {
 return key.hashCode();
 }
}

class MultiKeyList extends MultiKeyPair {
 ArrayList&lt;MultiKeyPair&gt; list = new ArrayList&lt;MultiKeyPair&gt;();

 public MultiKeyList(Object key) {
 super(key, null);
 }

 @Override
 public boolean equals(Object obj) {
 list.add((MultiKeyPair) obj);
 return false;
 }
}

public static void main(String[] args) {
 HashSet&lt;MultiKeyPair&gt; set = new HashSet&lt;MultiKeyPair&gt;();
 set.add(new MultiKeyPair("A","a1"));
 set.add(new MultiKeyPair("A","a2"));
 set.add(new MultiKeyPair("B","b1"));
 set.add(new MultiKeyPair("A","a3"));

 MultiKeyList o = new MultiKeyList("A");
 set.contains(o);

 for (MultiKeyPair pair : o.list) {
 System.out.println(pair.value);
 }
}
</code></pre>

blocks|key|78193|text|我使用了这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|78194|java.util.List<java.util.Map.Entry<String,Integer>>+pairList=+new+java.util.ArrayList<>();|offset|length|style|CODE|78195|entityMap^0|0|0|2I|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I used this:

<code>java.util.List&lt;java.util.Map.Entry&lt;String,Integer&gt;&gt; pairList= new java.util.ArrayList&lt;&gt;();</code>

blocks|key|4248898|text|class++DuplicateMap<K,+V>+
{
++++enum+MapType
++++{
++++++++Hash,LinkedHash
++++}

++++int+HashCode+=+0;
++++Map<Key<K>,V>+map+=+null;

++++DuplicateMap()
++++{
++++++++map+=+new+HashMap<Key<K>,V>();
++++}

++++DuplicateMap(+MapType+maptype+)
++++{
++++++++if+(+maptype+==+MapType.Hash+)+{
++++++++++++map+=+new+HashMap<Key<K>,V>();
++++++++}
++++++++else+if+(+maptype+==+MapType.LinkedHash+)+{
++++++++++++map+=+new+LinkedHashMap<Key<K>,V>();
++++++++}
++++++++else
++++++++++++map+=+new+HashMap<Key<K>,V>();
++++}

++++V+put(+K+key,+V+value++)
++++{

++++++++return+map.put(+new+Key<K>(+key+,+HashCode%2B%2B+),+value+);
++++}

++++void+putAll(+Map<K,+V>+map1+)
++++{
++++++++Map<Key<K>,V>+map2+=+new+LinkedHashMap<Key<K>,V>();

++++++++for+(+Entry<K,+V>+entry+:+map1.entrySet()+)+{
++++++++++++map2.put(+new+Key<K>(+entry.getKey()+,+HashCode%2B%2B+),+entry.getValue());
++++++++}
++++++++map.putAll(map2);
++++}

++++Set<Entry<K,+V>>+entrySet()
++++{
++++++++Set<Entry<K,+V>>+entry+=+new+LinkedHashSet<Map.Entry<K,V>>();
++++++++for+(+final+Entry<Key<K>,+V>+entry1+:+map.entrySet()+)+{
++++++++++++entry.add(+new+Entry<K,+V>(){
++++++++++++++++private+K+Key+=+entry1.getKey().Key();
++++++++++++++++private+V+Value+=+entry1.getValue();

++++++++++++++++@Override
++++++++++++++++public+K+getKey()+{
++++++++++++++++++++return+Key;
++++++++++++++++}

++++++++++++++++@Override
++++++++++++++++public+V+getValue()+{
++++++++++++++++++++return+Value;
++++++++++++++++}

++++++++++++++++@Override
++++++++++++++++public+V+setValue(V+value)+{
++++++++++++++++++++return+null;
++++++++++++++++}});
++++++++}

++++++++return+entry;
++++}

++++@Override
++++public+String+toString()+{
++++++++StringBuilder+builder+=+new++StringBuilder();
++++++++builder.append("{");
++++++++boolean+FirstIteration+=+true;
++++++++for+(+Entry<K,+V>+entry+:+entrySet()+)+{
++++++++++++builder.append(+(+(FirstIteration)?+""+:+","+)+%2B+((entry.getKey()==null)+?+null+:entry.getKey().toString()+)+%2B+"="+%2B+((entry.getValue()==null)+?+null+:entry.getValue().toString()+)++);
++++++++++++FirstIteration+=+false;
++++++++}
++++++++builder.append("}");
++++++++return+builder.toString();
++++}

++++class+Key<K1>
++++{
++++++++K1+Key;
++++++++int+HashCode;

++++++++public+Key(K1+key,+int+hashCode)+{
++++++++++++super();
++++++++++++Key+=+key;
++++++++++++HashCode+=+hashCode;
++++++++}

++++++++public+K1+Key()+{
++++++++++++return+Key;
++++++++}

++++++++@Override
++++++++public+String+toString()+{
++++++++++++return++Key.toString()+;
++++++++}

++++++++@Override
++++++++public+int+hashCode()+{

++++++++++++return+HashCode;
++++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4248899|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class DuplicateMap&lt;K, V&gt; 
{
 enum MapType
 {
 Hash,LinkedHash
 }

 int HashCode = 0;
 Map&lt;Key&lt;K&gt;,V&gt; map = null;

 DuplicateMap()
 {
 map = new HashMap&lt;Key&lt;K&gt;,V&gt;();
 }

 DuplicateMap( MapType maptype )
 {
 if ( maptype == MapType.Hash ) {
 map = new HashMap&lt;Key&lt;K&gt;,V&gt;();
 }
 else if ( maptype == MapType.LinkedHash ) {
 map = new LinkedHashMap&lt;Key&lt;K&gt;,V&gt;();
 }
 else
 map = new HashMap&lt;Key&lt;K&gt;,V&gt;();
 }

 V put( K key, V value )
 {

 return map.put( new Key&lt;K&gt;( key , HashCode++ ), value );
 }

 void putAll( Map&lt;K, V&gt; map1 )
 {
 Map&lt;Key&lt;K&gt;,V&gt; map2 = new LinkedHashMap&lt;Key&lt;K&gt;,V&gt;();

 for ( Entry&lt;K, V&gt; entry : map1.entrySet() ) {
 map2.put( new Key&lt;K&gt;( entry.getKey() , HashCode++ ), entry.getValue());
 }
 map.putAll(map2);
 }

 Set&lt;Entry&lt;K, V&gt;&gt; entrySet()
 {
 Set&lt;Entry&lt;K, V&gt;&gt; entry = new LinkedHashSet&lt;Map.Entry&lt;K,V&gt;&gt;();
 for ( final Entry&lt;Key&lt;K&gt;, V&gt; entry1 : map.entrySet() ) {
 entry.add( new Entry&lt;K, V&gt;(){
 private K Key = entry1.getKey().Key();
 private V Value = entry1.getValue();

 @Override
 public K getKey() {
 return Key;
 }

 @Override
 public V getValue() {
 return Value;
 }

 @Override
 public V setValue(V value) {
 return null;
 }});
 }

 return entry;
 }

 @Override
 public String toString() {
 StringBuilder builder = new StringBuilder();
 builder.append("{");
 boolean FirstIteration = true;
 for ( Entry&lt;K, V&gt; entry : entrySet() ) {
 builder.append( ( (FirstIteration)? "" : "," ) + ((entry.getKey()==null) ? null :entry.getKey().toString() ) + "=" + ((entry.getValue()==null) ? null :entry.getValue().toString() ) );
 FirstIteration = false;
 }
 builder.append("}");
 return builder.toString();
 }

 class Key&lt;K1&gt;
 {
 K1 Key;
 int HashCode;

 public Key(K1 key, int hashCode) {
 super();
 Key = key;
 HashCode = hashCode;
 }

 public K1 Key() {
 return Key;
 }

 @Override
 public String toString() {
 return Key.toString() ;
 }

 @Override
 public int hashCode() {

 return HashCode;
 }
 }
</code></pre>

blocks|key|78213|text|这个问题可以通过映射条目List<Map.Entry<K,V>>的列表来解决。我们既不需要使用外部库，也不需要使用Map的新实现。可以按如下方式创建地图条目：Map.Entry<String,+Integer>+entry+=+new+AbstractMap.SimpleEntry<String,+Integer>("key",+1);|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|78214|entityMap^0|C|K|27|2I|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

This problem can be solved with a list of map entry <code>List&lt;Map.Entry&lt;K,V&gt;&gt;</code>. We don't need to use neither external libraries nor new implementation of Map. A map entry can be created like this:
 <code>Map.Entry&lt;String, Integer&gt; entry = new AbstractMap.SimpleEntry&lt;String, Integer&gt;("key", 1);</code>

blocks|key|1378687|text|+1,+Map<String,+List<String>>+map+=+new+HashMap<>();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1378688|unstyled|1378689|这种冗长的解决方案有多个缺点，并且容易出错。这意味着我们需要为每个值实例化一个Collection，在添加或删除值之前检查它的存在，在没有值的时候手动删除它，等等。|blockquote|1378690|1378691|1378692|2,+org.apache.commons.collections4.MultiMap+interface
3,+com.google.common.collect.Multimap+interface+|1378693|java-map-duplicate-keys|offset|length|1378694|entityMap|0|LINK|mutability|MUTABLE|url|https://www.baeldung.com/java-map-duplicate-keys^0|0|0|0|0|0|0|0|N|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|10|8|@]|9|@]|A|$]]|$1|I|3|-4|5|E|7|11|8|@]|9|@]|A|$]]|$1|J|3|-4|5|E|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|13|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|E|7|14|8|@]|9|@$O|15|P|16|1|17]]|A|$]]|$1|Q|3|-4|5|E|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

<pre><code> 1, Map&lt;String, List&lt;String&gt;&gt; map = new HashMap&lt;&gt;();
</code></pre>

<blockquote>
 this verbose solution has multiple drawbacks and is prone to errors. It 
 implies that we need to instantiate a Collection for every value, check for 
 its presence before adding or removing a value, delete it manually when no 
 values are left, etcetera.
</blockquote>

<pre><code>2, org.apache.commons.collections4.MultiMap interface
3, com.google.common.collect.Multimap interface 
</code></pre>

<a href="https://www.baeldung.com/java-map-duplicate-keys" rel="nofollow noreferrer">java-map-duplicate-keys</a>

blocks|key|1031551|text|这样的MultiMap实现又如何呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1031552|public+class+MultiMap<K,+V>+extends+HashMap<K,+Set<V>>+{
++private+static+final+long+serialVersionUID+=+1L;
++private+Map<K,+Set<V>>+innerMap+=+new+HashMap<>();

++public+Set<V>+put(K+key,+V+value)+{
++++Set<V>+valuesOld+=+this.innerMap.get(key);
++++HashSet<V>+valuesNewTotal+=+new+HashSet<>();
++++if+(valuesOld+!=+null)+{
++++++valuesNewTotal.addAll(valuesOld);
++++}
++++valuesNewTotal.add(value);
++++this.innerMap.put(key,+valuesNewTotal);
++++return+valuesOld;
++}

++public+void+putAll(K+key,+Set<V>+values)+{
++++for+(V+value+:+values)+{
++++++put(key,+value);
++++}
++}

++@Override
++public+Set<V>+put(K+key,+Set<V>+value)+{
++++Set<V>+valuesOld+=+this.innerMap.get(key);
++++putAll(key,+value);
++++return+valuesOld;
++}

++@Override
++public+void+putAll(Map<?+extends+K,+?+extends+Set<V>>+mapOfValues)+{
++++for+(Map.Entry<?+extends+K,+?+extends+Set<V>>+valueEntry+:+mapOfValues.entrySet())+{
++++++K+key+=+valueEntry.getKey();
++++++Set<V>+value+=+valueEntry.getValue();
++++++putAll(key,+value);
++++}
++}

++@Override
++public+Set<V>+putIfAbsent(K+key,+Set<V>+value)+{
++++Set<V>+valueOld+=+this.innerMap.get(key);
++++if+(valueOld+==+null)+{
++++++putAll(key,+value);
++++}
++++return+valueOld;
++}

++@Override
++public+Set<V>+get(Object+key)+{
++++return+this.innerMap.get(key);
++}

++@Override
++etc.+etc.+override+all+public+methods+size(),+clear()+.....

}|code-block|syntax|javascript|1031553|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

what about such a MultiMap impl?

<pre><code>public class MultiMap&lt;K, V&gt; extends HashMap&lt;K, Set&lt;V&gt;&gt; {
 private static final long serialVersionUID = 1L;
 private Map&lt;K, Set&lt;V&gt;&gt; innerMap = new HashMap&lt;&gt;();

 public Set&lt;V&gt; put(K key, V value) {
 Set&lt;V&gt; valuesOld = this.innerMap.get(key);
 HashSet&lt;V&gt; valuesNewTotal = new HashSet&lt;&gt;();
 if (valuesOld != null) {
 valuesNewTotal.addAll(valuesOld);
 }
 valuesNewTotal.add(value);
 this.innerMap.put(key, valuesNewTotal);
 return valuesOld;
 }

 public void putAll(K key, Set&lt;V&gt; values) {
 for (V value : values) {
 put(key, value);
 }
 }

 @Override
 public Set&lt;V&gt; put(K key, Set&lt;V&gt; value) {
 Set&lt;V&gt; valuesOld = this.innerMap.get(key);
 putAll(key, value);
 return valuesOld;
 }

 @Override
 public void putAll(Map&lt;? extends K, ? extends Set&lt;V&gt;&gt; mapOfValues) {
 for (Map.Entry&lt;? extends K, ? extends Set&lt;V&gt;&gt; valueEntry : mapOfValues.entrySet()) {
 K key = valueEntry.getKey();
 Set&lt;V&gt; value = valueEntry.getValue();
 putAll(key, value);
 }
 }

 @Override
 public Set&lt;V&gt; putIfAbsent(K key, Set&lt;V&gt; value) {
 Set&lt;V&gt; valueOld = this.innerMap.get(key);
 if (valueOld == null) {
 putAll(key, value);
 }
 return valueOld;
 }

 @Override
 public Set&lt;V&gt; get(Object key) {
 return this.innerMap.get(key);
 }

 @Override
 etc. etc. override all public methods size(), clear() .....

}
</code></pre>

blocks|key|78278|text|不需要花哨的库。映射是由一个唯一的键定义的，所以不要弯曲它们，使用列表。小溪是强大的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|78279|import+java.util.AbstractMap.SimpleImmutableEntry;

List<SimpleImmutableEntry<String,+String>>+nameToLocationMap+=+Arrays.asList(
++++new+SimpleImmutableEntry<>("A",+"A1"),
++++new+SimpleImmutableEntry<>("A",+"A2"),
++++new+SimpleImmutableEntry<>("B",+"B1"),
++++new+SimpleImmutableEntry<>("B",+"B1"),
);|code-block|syntax|javascript|78280|就是这样。使用示例：|78281|List<String>+allBsLocations+=+nameToLocationMap.stream()
++++++++.filter(x+->+x.getKey().equals("B"))
++++++++.map(x+->+x.getValue())
++++++++.collect(Collectors.toList());

nameToLocationMap.stream().forEach(x+->+
do+stuff+with:+x.getKey()...x.getValue()...|78282|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

No fancy libs required.
Maps are defined by a unique key, so dont bend them, use a list. Streams are mighty.

<pre><code>import java.util.AbstractMap.SimpleImmutableEntry;

List&lt;SimpleImmutableEntry&lt;String, String&gt;&gt; nameToLocationMap = Arrays.asList(
 new SimpleImmutableEntry&lt;&gt;("A", "A1"),
 new SimpleImmutableEntry&lt;&gt;("A", "A2"),
 new SimpleImmutableEntry&lt;&gt;("B", "B1"),
 new SimpleImmutableEntry&lt;&gt;("B", "B1"),
);
</code></pre>

And thats it. 
Usage examples:

<pre><code>List&lt;String&gt; allBsLocations = nameToLocationMap.stream()
 .filter(x -&gt; x.getKey().equals("B"))
 .map(x -&gt; x.getValue())
 .collect(Collectors.toList());

nameToLocationMap.stream().forEach(x -&gt; 
do stuff with: x.getKey()...x.getValue()...
</code></pre>

blocks|key|4249179|text|您可以使用带有自定义比较器的TreeMap，以便将每个键视为与其他键不相等。它还会保留地图中的插入顺序，就像LinkedHashMap一样。因此，最终的结果就像一个允许重复键的LinkedHashMap！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4249180|这是一个非常简单的实现，不需要任何第三方依赖或复杂的MultiMaps。|4249181|import+java.util.Map;
import+java.util.TreeMap;

...
...

//Define+a+TreeMap+with+a+custom+Comparator
Map<Integer,+String>+map+=+new+TreeMap<>((a,+b)+->+1);+//+See+notes+1+and+2

//Populate+the+map
map.put(1,+"One");
map.put(3,+"Three");
map.put(1,+"One+One");
map.put(7,+"Seven");
map.put(2,+"Two");
map.put(1,+"One+One+One");
++++
//Display+the+map+entries:
map.entrySet().forEach(System.out::println);

//See+note+number+3+for+the+following:
Map<Integer,+String>+sortedTreeMap+=+map.entrySet().stream()
++++++++++++.sorted(Map.Entry.comparingByKey())
++++++++++++.collect(Collectors.toMap(
++++++++++++++++Map.Entry::getKey,+Map.Entry::getValue,
++++++++++++++++(x,+y)+->+x,+()+->+new+TreeMap<>((a,+b)+->+1)
+++++++++++++));
//Display+the+entries+of+this+sorted+TreeMap:+
sortedTreeMap.entrySet().forEach(System.out::println);

++++
...|code-block|syntax|javascript|4249182|备注：|4249183|4249184|您还可以在此处使用任何正整数代替比较器定义中的1。|ordered-list-item|4249185|如果您使用任何负整数，则它将颠倒地图中的插入顺序。|4249186|如果您还想根据键对此地图进行排序(这是TreeMap的默认行为)，则可以在当前地图上执行此操作。|4249187|4249188|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|N|7|11|8|@]|9|@]|A|$]]|$1|Q|3|R|5|N|7|12|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|U|$]]

You can use a TreeMap with a custom Comparator in order to treat each key as unequal to the others. It would also preserve the insertion order in your map, just like a LinkedHashMap. So, the net result would be like a LinkedHashMap which allows duplicate keys!
This is a very simple implementation without the need of any third party dependencies or complications of MultiMaps.
<pre><code>import java.util.Map;
import java.util.TreeMap;

...
...

//Define a TreeMap with a custom Comparator
Map&lt;Integer, String&gt; map = new TreeMap&lt;&gt;((a, b) -&gt; 1); // See notes 1 and 2

//Populate the map
map.put(1, &quot;One&quot;);
map.put(3, &quot;Three&quot;);
map.put(1, &quot;One One&quot;);
map.put(7, &quot;Seven&quot;);
map.put(2, &quot;Two&quot;);
map.put(1, &quot;One One One&quot;);
 
//Display the map entries:
map.entrySet().forEach(System.out::println);

//See note number 3 for the following:
Map&lt;Integer, String&gt; sortedTreeMap = map.entrySet().stream()
 .sorted(Map.Entry.comparingByKey())
 .collect(Collectors.toMap(
 Map.Entry::getKey, Map.Entry::getValue,
 (x, y) -&gt; x, () -&gt; new TreeMap&lt;&gt;((a, b) -&gt; 1)
 ));
//Display the entries of this sorted TreeMap: 
sortedTreeMap.entrySet().forEach(System.out::println);

 
...
</code></pre>
Notes:
<ol>
<li>You can also use any positive integer in place of 1 in the comparator's definition here.</li>
<li>If you use any negative integer instead, then it will reverse the insertion order in your map.</li>
<li>If you also want to sort this map based on the keys (which is the default behavior of a TreeMap), then you may do this operation on the current map.</li>
</ol>

I want to have a map with duplicate keys.

I know there are many map implementations (Eclipse shows me about 50), so I bet there must be one that allows this. I know it's easy to write your own map that does this, but I would rather use some existing solution.

Maybe something in commons-collections or google-collections?

Map implementation with duplicate keys

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想要一个具有重复键的映射。我知道有很多map实现(Eclipse向我展示了大约50个)，所以我打赌肯定有一个允许这样做。我知道编写自己的地图很容易做到这一点，但我更愿意使用一些现有的解决方案。也许是commons-collections或google-collections中的一些东西？

问具有重复键的映射实现
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问具有重复键的映射实现EN