用作哈希键的 java 对象是否需要“完全”不可变？

Question

如果 hashCode() 计算 使用不可变字段 并且 equals() 使用所有字段，当类用作哈希键时会不会有问题？例如

import java.util.Objects;

public class Car {
    protected final long vin;
    protected String state;
    protected String plateNumber;

    public Car( long v, String s, String p ) {
        vin = v; state = s; plateNumber = p;
    }


    public void move( String s, String p ) {
        state = s; plateNumber = p;
    }


    public int hashCode() {
        return (int)( vin % Integer.MAX_VALUE );
    }


    public boolean equals( Object other ) {
        if (this == other) return true;
        else if (!(other instanceof Car)) return false;
        Car otherCar = (Car) other;
        return vin == otherCar.vin
                && Objects.equals( state, otherCar.state )
                && Objects.equals( plateNumber, otherCar.plateNumber );
    }
}

在汽车对象插入哈希集后，它会在汽车对象上调用 move()，这可能通过保存在别处的引用来实现。

我不关心这里的性能问题。只有正确性。

我已阅读 java hashCode contact，关于 SO 的答案很少，包括尊敬的 Jon Skeet 的 this 和来自 big blue 的 this。我觉得最后一个链接给出了最好的解释，暗示上面的代码是正确的。

编辑

结论：
此类满足 java 中对“equals()”和“hashCode()”的约束。然而，当用作集合中的键时，它违反了对“equals()”的附加要求，无论是否散列。
附加要求是，只要对象是键，'equals()' 需要保持一致。
请参阅下面 Louis Wasserman 的反例和 Douglas 提供的参考资料。

一些澄清：

A) 这个类满足 java 对象级别的约束：

1. （carA == carB）暗示（carA.hashCode() == carB.hashCode()）
2. ( carA.hashCode() != carB.hashCode() ) 暗示 (carA != carB )
3. equals() 需要是自反的、对称的、传递的。
4. hashCode() 需要保持一致。即在其生命周期内无法更改对象。
5. equals() 需要保持一致只要两个对象都没有被修改。

请注意，“1.”和“2.”的倒数不是必需的。并且上面的类满足所有条件。
java 文档还提到 "equals() ... 在对象上实现了最有区别的可能等价关系"，但不确定这是否是强制性的。

B) 至于性能，碰撞避免概率的增量随着我们组合的每个连续成员变量而降低。通常选择几个精心挑选的成员变量就足够了。

Answer 1

哈希通过将项目放入“桶”来工作。每个桶由hashcode 计算。找到存储桶后，搜索继续使用equals 逐一比较每个项目。

例如：

• 插入过程中：将id为100的对象放入桶5（计算出的hashcode为5）。
• 在检索期间：您要求哈希图查找项目 100。如果哈希现在计算为 7，那么算法将在存储桶 7 中搜索您的对象，但您的对象将永远不会被找到，因为它位于存储桶 5 中。李>

总而言之：哈希码和实际密钥一起工作。前者用于知道该项目应该在哪个桶中。后者由equals 比较使用，以寻找要返回的实际项目。

Answer 2

简短回答：应该没问题，但要为奇怪的行为做好准备。

更长的答案：当您更改某个键上参与 equals() 的字段时，将不再找到由该键键入的值。

更长的答案：这看起来像 X/Y 问题：你在问 X，但你确实需要 X 来完成 Y。也许你应该问 Y？

您的汽车由vin 唯一标识。一辆车等于它自己。但是，汽车可以在不同的州注册。也许答案是在汽车上附加一个注册对象（或其中一些）？然后您可以将car.equals() 与registration.equals() 分开。

Answer 3

当只考虑hashCode 和equals 合约时，你是正确的，这个实现满足他们的要求。 hashCode 使用 equals 使用的字段的严格子集足以保证 a.equals(b) 根据需要隐含 a.hashCode() == b.hashCode()。

但是，当您引入 Map 时，情况会发生变化。来自Map javadoc，“如果对象的值以影响等于比较的方式更改，而对象是映射中的键，则不会指定映射的行为。”

在 Car 上调用 move（这是 Map 中的一个键）后，该 Map 的行为现在未指定。在许多情况下，它实际上仍会按照您希望的方式工作，但奇怪的事情可能会以难以预测的方式发生。虽然从技术上讲，Map 自发清空或切换所有查找以使用随机数生成器在技术上是有效的，但更可能的情况可能是这样的：

Car car1 = ... Car car2 = ... // a copy of car1 Map<Car, String> map1 = ... map1.put(car1, "value"); assert map1.get(car2).equals("value"); // true car1.move(...); assert map1.get(car2).equals("value"); // NullPointerException on the equals call, car2 is no longer found

请注意，car2 和 Map 本身都没有发生任何变化，但 car2 的映射无论如何都发生了变化（或者更确切地说，消失了）。这种行为没有正式规定，但我猜大多数 Map 实现确实有这种行为。

Answer 4

您可以在在它们被用作键之前或之后（而不是期间）尽可能多地改变您的关键候选者。 在实践中，执行此规则非常困难。如果你改变对象，你无法控制是否有人将它们用作键。

密钥的不变性更容易，消除了微妙的、难以发现的错误的来源，并且更好地为密钥工作。

在您的情况下，我没有发现正确性问题。但是，为什么您会费心不在哈希码中包含所有字段呢？

Answer 5

简短的回答是：不。

长答案：

不需要完全不变。但是：

Equals 只能依赖于不可变的值。哈希码必须依赖于不可变的值，要么是常量，要么是 equals 中使用的值的子集，或者 equals 中使用的所有值。 equals 中未提及的值不能是哈希码的一部分。

如果您改变值 equals 并且哈希码依赖于它，您可能不会在基于哈希的数据结构中再次找到您的对象。看看这个：

public class Test {


    private static class TestObject {
        private String s;

        public TestObject(String s) {
            super();
            this.s = s;
        }

        public void setS(String s) {
            this.s = s;
        }

        @Override
        public boolean equals(Object obj) {
            boolean equals = false;
            if (obj instanceof TestObject) {
                TestObject that = (TestObject) obj;
                equals = this.s.equals(that.s);
            }
            return equals;
        }

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

    public static void main(String[] args) {

        TestObject a1 = new TestObject("A");
        TestObject a2 = new TestObject("A");

        System.out.println(a1.equals(a2)); // true

        HashMap<TestObject, Object> hashSet = new HashMap<>(); // hash based datastructure

        hashSet.put(a1, new Object());

        System.out.println(hashSet.containsKey(a1)); // true

        a1.setS("A*");

        System.out.println(hashSet.containsKey(a1)); // false !!! // Object is not found as the hashcode used initially before mutation was used to determine the hash bucket

        a2.setS("A*");

        System.out.println(hashSet.containsKey(a2)); // false !!! Because a1 is in wrong hash bucket ...

        System.out.println(a1.equals(a2)); // ... even if the objects are equals

    }

}

Answer 6

当您的 hashCode() 实现仅使用有限数量的字段（与 equals 相比）时，您会降低几乎所有使用散列的算法/数据结构的性能：HashMap、HashSet 等。您正在增加碰撞概率 - 这是两个不同对象（equals 返回 false）具有相同哈希值的情况。

Answer 7

在Car 出现在地图中之后，您永远不会调用move，这是正确的。否则就错了。 hashCode 和 equals 都必须在地图中出现键后保持一致。