Java-向现有HashMap键添加另一个字符串值而不覆盖？

我想知道是否有人能够帮助在Java中的

HashMap

中向现有键添加另一个

String

值

我知道您可以使用

this.put（“String”、“String”）

方法添加键值对。但是，它会覆盖现有值，而我希望使用同一个键存储并配对多个值

---

谢谢您的帮助。

您想要两个字符串的串联吗

map.put(key, val);
if (map.containsKey(key)) {
    map.put(key, map.get(key) + newVal);
}

或者您想要该键的所有值的列表吗

HashMap<String,List<String>> map = new HashMap<String,List<String>>();
String key = "key";
String val = "val";
String newVal = "newVal";
List<String> list = new ArrayList<String>();
list.add(val);
map.put(key, list);
if (map.containsKey(key)) {
    map.get(key).add(newVal);
}

HashMap map=newhashmap（）；
字符串key=“key”；
字符串val=“val”；
字符串newVal=“newVal”；
列表=新的ArrayList（）；
列表。添加（val）；
地图。放置（键、列表）；
if（地图容器（图例））{
map.get（key）.add（newVal）；
}

将值存储为映射下的列表，所以如果键是test，并且有两个值，比如val1和val2，那么键将是test，值将是包含val1和val2的列表

但是，如果您的目的是为同一个键创建两个单独的条目，那么这并不是为地图设计的。试想一下，如果您使用map.get（“key”），您希望map中描述的哪个值包含一组键，因此它不能包含多个非唯一键

---

我建议您使用列表作为此映射的值。

正如其他人指出的那样，

map

by specification对于给定的键只能有一个值。您有两种解决方案：

• 使用

  HashMap

  存储数据
• 由第三方谷歌收藏库提供的使用

---

您可以使用

映射

，但是添加和删除值会很麻烦。更好的方法是使用guava—一个允许为每个键存储多个值的容器。

您不能在单个键下直接存储多个值，但与键关联的值可以是任何类型的对象，例如ArrayList，它将保存多个值。例如：

import java.util.ArrayList;
import java.util.HashMap;

public class HashMapList {
    HashMap<String, ArrayList<String>> strings = new HashMap<String, ArrayList<String>>();

    public void add(String key, String value) {
        ArrayList<String> values = strings.get(key);
        if (values == null) {
            values = new ArrayList<String>();
            strings.put(key, values);
        }

        values.add(value);
    }

    public ArrayList<String> get(String key) {
        return strings.get(key);
    }

    public static void main(String[] argv) {
        HashMapList mymap = new HashMapList();

        mymap.add("key", "value1");
        mymap.add("key", "value2");

        ArrayList<String> values = mymap.get("key");
        for (String value : values) {
            System.out.println(value);
        }
    }
}

import java.util.ArrayList；
导入java.util.HashMap；
公共类HashMapList{
HashMap字符串=新的HashMap（）；
公共void添加（字符串键、字符串值）{
ArrayList值=strings.get（键）；
如果（值==null）{
值=新的ArrayList（）；
strings.put（键、值）；
}
增加（价值）；
}
公共ArrayList get（字符串键）{
返回strings.get（key）；
}
公共静态void main（字符串[]argv）{
HashMapList mymap=新建HashMapList（）；
添加（“键”、“值1”）；
添加（“键”、“值2”）；
arraylistvalues=mymap.get（“key”）；
for（字符串值：值）{
系统输出打印项次（值）；
}
}
}

这是不可能的，因为如果使用字符串作为map的键，则字符串是不可变的。相同键的值具有相同的hashcode值。

您希望在这里实现什么

在您的例子中，

Map

（HashMap）是从一个“键”到另一个值的直接“映射”

例如

这意味着，如果您要尝试：

myHashMap.get("foo");

它将返回值

123

（当然，您返回的值的类型可以是您想要的任何类型）

当然，这也意味着您对键的值所做的任何更改都将覆盖您为其指定的原始值，就像更改变量的值将覆盖指定的原始值一样

说：

地图中

“foo”

的旧值将替换为

42

。因此，它将成为：

"foo" -> 42
"bar" -> 321
"far" -> 12345
"boo" -> 54321

但是，如果需要从一个键映射多个

String

对象，可以使用可以存储多个对象的不同对象，例如数组或列表（如果需要，甚至可以使用另一个

HashMap

）

例如，如果要使用

ArrayLists

，则在为

HashMap

赋值时（假设它被称为

myHashMap

），首先检查该键以前是否使用过，如果没有，则使用要添加的值创建一个新的

ArrayList

，如果有，则只需将该值添加到列表中即可

（假设

键

和

值

具有所需的值）

ArrayList列表；
if（myHashMap.containsKey（键））{
//如果已经使用了密钥，
//我们只需要抓取数组列表并向其中添加值
list=myHashMap.get（key）；
列表。添加（值）；
}否则{
//如果钥匙还没用过，
//我们将创建一个新的ArrayList对象，添加值
//并使用新键将其放入数组列表中
列表=新的ArrayList（）；
列表。添加（值）；
myHashMap.put（键，列表）；
}

你可以这样做

Map<String,List<String>> map = new HashMap<>();
.
.
if(map.containsKey(key)){
    map.get(key).add(value);
} else {
   List<String> list = new ArrayList<>();
   list.add(value);
   map.put(key, list);
}

Map Map=newhashmap（）；
.
.
if（地图容器（图例））{
map.get（key）、add（value）；
}否则{
列表=新的ArrayList（）；
列表。添加（值）；
地图。放置（键、列表）；
}

或您可以通过Java 8风格的一行代码来完成同样的事情

map.computeIfAbsent(key, k ->new ArrayList<>()).add(value);

map.computeIfAbsent（key，k->newArrayList（））.add（value）；

编写您自己的自定义类，其中字符串将作为您的实例变量，并重写equals和hashcode方法并使用它，我的问题是，为什么要这样做？“在Java的HashMap中向现有键添加另一个字符串值”不太清楚。

map.put（“foo”，“bar”）的结果应该是什么；map.put（“foo”，“bar”）

？foo键的值应该是什么？应该是

“barbar”

还是类似list

“[bar，bar]”之类的东西？

或者您希望只有唯一的值，所以它仍然应该是

“bar”

？散列的是键，而不是值。

ArrayList<String> list;
if(myHashMap.containsKey(key)){
    // if the key has already been used,
    // we'll just grab the array list and add the value to it
    list = myHashMap.get(key);
    list.add(value);
} else {
    // if the key hasn't been used yet,
    // we'll create a new ArrayList<String> object, add the value
    // and put it in the array list with the new key
    list = new ArrayList<String>();
    list.add(value);
    myHashMap.put(key, list);
}

Map<String,List<String>> map = new HashMap<>();
.
.
if(map.containsKey(key)){
    map.get(key).add(value);
} else {
   List<String> list = new ArrayList<>();
   list.add(value);
   map.put(key, list);
}

map.computeIfAbsent(key, k ->new ArrayList<>()).add(value);