更新 Java HashMap 键

Question

我只是想知道，如果 HashMap 的键是可变的会发生什么，下面的测试程序证明了这一点，我无法理解 equals 和 hashCode 方法何时返回 true 和相同的值，为什么hashmap.containsKey 返回false。

public class MutableKeyHashMap {

    public static void main(String []a){

            HashMap<Mutable, String> map = new HashMap<Mutable, String>();
            Mutable m1 = new Mutable(5);
            map.put(m1, "m1");
            Mutable m2 = new Mutable(5);
            System.out.println(map.containsKey(m2));    

            m2.setA(6);
            m1.setA(6);
            Mutable m3 = map.keySet().iterator().next();

            System.out.println(map.containsKey(m2)+"    "+m3.hashCode()+"       "+m2.hashCode()+"       "+m3.equals(m2));   

    }
}
class Mutable {

    int a;

    public Mutable(int a) {

        this.a = a;
    }

    @Override
    public boolean equals(Object obj) {

        Mutable m = (Mutable) obj;
        return m.a == this.a ? true : false; 
    }

    @Override
    public int hashCode(){
        return a;
    }

    public void setA(int a) {

        this.a = a;
    }

    public int getA() {
        return a;
    }
} 

这是输出：

真 假 6 6 真

Answer 1

javadoc 解释它

注意：如果将可变对象用作映射键，则必须非常小心。如果对象的值以影响等于比较的方式更改，而对象是映射中的键，则不会指定映射的行为。

基本上，不要在 Map 中使用可变对象作为键，你会被烧毁

推断，因为文档可能看起来不清楚，我相信这里的相关点是“以影响 equals 的方式进行更改”，并且您似乎假设每次调用 contains 时都会调用 equals(Object)。文档没有这么说，措辞暗示它们可能被允许缓存计算。

查看source，似乎因为您的 hashCode 返回了一个不同的值（以前是 5，现在是 6），可能是根据实现细节在不同的存储桶中查找它。

Answer 2

你可以这样想，如果 Map 有 16 个桶。当你给它一个 A == 5 的对象时，它会将它扔到存储桶 5 中。现在你可以将 A 更改为 6，但它仍然在存储桶 5 中。地图不知道你更改了 A，它不会重新排列东西内部。

现在你带着另一个 A == 6 的对象过来，你问地图是否有其中一个。它去查看 6 号桶，然后说“不，那里什么都没有”。它不会为您检查所有其他存储桶。

显然，如何将事物放入桶中比这更复杂，但这就是它的核心工作方式。

Answer 3

HashMap 将您的对象放在哈希键 5 的位置。然后你把key改成6，用containsKey询问map是否包含对象。地图查看位置 6 并没有找到任何东西，所以它回答 false。

那么，不要那样做。

Answer 4

当您第一次输入“m1”时，hashCode() 是 5。因此，HashMap 使用 5 将值放入适当的存储桶中。更改 m2 后，hashCode() 为 6，因此当您尝试查找放入的值时，它查找的存储桶不同。

Answer 5

ptomli 回答的代码示例。

import java.util.*;

class Elem {
    private int n;

    public Elem(int n) {
        this.n = n;
    }

    public void setN(int n) {
        this.n = n;
    }

    @Override
    public int hashCode() {
        return n;
    }

    @Override
    public boolean equals(Object e) {
        if (this == e)
            return true;
        if (!(e instanceof Elem))
            return false;
        Elem an = (Elem) e;
        return n == an.n;
    }
}

public class MapTest {
    public static void main (String [] args)  {
        Elem e1 = new Elem(1);
        Elem e2 = new Elem(2);

        HashMap map = new HashMap();
        map.put(e1, 100);
        map.put(e2, 200);

        System.out.println("before modification: " + map.get(e1));  
        e1.setN(9);
        System.out.println("after modification using updated key: " + map.get(e1)); 

        Elem e3 = new Elem(1);
        System.out.println("after modification using key which equals to the original key: " + map.get(e3));    
    }
}

编译并运行它。结果是：

before modification: 100
after modification using updated key: null
after modification using key which equals to the original key: null

我在 Linux 上使用 Java 6。