2

以下程序维护 2 个数据结构，名为：

map of type HashMap
map_1 also of type HashMap

开头map是key : 1和value : suhail。然后这个映射被插入到map_1key20中。

再次map填充了key : 1另一个value : CSE. 这张地图再次插入到map_1.

import java.util.*;

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

        Map<Integer,Object> map_1 = new HashMap<Integer,Object>();

        map.put(1,"suhail");

        map_1.put(20,map);

        map.put(1,"CSE");

        map_1.put(21,map);

        Set<Integer> keys = map_1.keySet();
        Iterator i = keys.iterator();
        while(i.hasNext()) {
            System.out.println(map_1.get((Integer)i.next()));
        }

    }
}

map_1当我打印值时，这就是我得到的：

{1=CSE}
{1=CSE}

但这不是我所期望的。据我所知，这是程序应该运行的方式：

[1,suhail]--> map
[20,[1,suhail]]---> map_1
[1,CSE]--> map (A replace, because of the same keys)
[21,[1,CSE]]--->map_1

所以输出应该是：

[1,suhail]
[1,CSE]

谁能解释一下，为什么我没有得到这个输出

4

5 回答 5

4

当您将对象map插入map_1时，它不会被复制。当您在 之外修改它时map_1，存储的对象也会被修改，因为它是同一个对象。

重新分配新地图map以解决此问题：

Map<Integer,Object> map_1 = new HashMap<Integer,Object>();
Map<Integer,String> map = new HashMap<Integer,String>();

map.put(1,"suhail");
// The first "map" object gets inserted
map_1.put(20,map);

// Make a new object
map = new HashMap<Integer,String>();

map.put(1,"CSE");
// Now the second object gets inserted
map_1.put(21,map);
于 2013-08-27T11:11:59.543 回答
0

在地图中，您可以一对一value，key因此如果您再次将某些内容放在将被新对象替换的同一键上。因此，当您再次将某些东西放在key:1该值上时，它会被替换。您必须创建一个新对象来绕过该行为意味着新地图。

并且您已将 map ref 放入 map1 中，因此当您对其进行编辑时，其内部副本也会被修改。

于 2013-08-27T11:12:48.763 回答
0

那是因为您要覆盖同一个 Map 实例中的最后一个值。

map <- [1: "suhail"]
map_1 <- [20: [1: "suhail"]]

map <- 1, 'CSE' (you lost "suhail", overwriting key 1) [1: "CSE"]
map_1 <- 21, map, same object in two different keys. [20: [1: "CSE"], 21: [1: "CSE"]]

在这种情况下，您具有与 中的两个不同键相关的相同实例map_1。

要做你想做的事，你必须为map.

import java.util.*;

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

        Map<Integer,Object> map_1 = new HashMap<Integer,Object>();

        map.put(1,"suhail");

        map_1.put(20,map);

        map = new HashMap<Integer,String>();
        map.put(1,"CSE");

        map_1.put(21,map);

        Set<Integer> keys = map_1.keySet();
        Iterator i = keys.iterator();
        while(i.hasNext()) {
            System.out.println(map_1.get((Integer)i.next()));
        }

    }
}
于 2013-08-27T11:13:17.390 回答
0

输出是正确的，在下面的语句中

map.put(1,"suhail"); 
//--> map has [1 = suhail]
map_1.put(20,map);  
//--> map1 has [20 = [1 = suhail]]
map.put(1,"CSE"); 
//--> You are modifying the same map reference, hence now map is [1 = "CSE"]
map_1.put(21,map); 
//--> you are putting the same map ref to map1 with new key so map1 is [20 = [1 = "CSE"], [21 = [1 = "CSE"]]

由于您使用的是相同 map的对象，因此输出就是这样。如果您想创建一个新的map，您可能需要分配一个新HashMap的map参考

您只打印值，因此输出

于 2013-08-27T11:13:38.923 回答
0

这是因为您将对象的引用存储在地图中，而不是它的值。在您的 map_1 中，键 20 和 21 都链接到同一个对象（地图）。如果您希望它们不同（例如在循环中），则必须为每个键创建一个新的映射对象。

顺便说一句，您只是打印值，而不是键，这就是为什么 20 和 21 没有显示在输出中的原因（当然，假设这是问题的一部分）

希望对您有所帮助。

于 2013-08-27T11:15:43.730 回答