如果 hashcode returns 是常量值，在 HashSet.contains() 情况下调用 hashCode() 和 equals() 的次数

Question

我已经阅读了 Java 文档页面，但我无法解释，为什么 hashCode() 和 equals() 的调用次数会像这样变化？

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class NumberOfCalls {
    int field;

    public int getField() {
        return field;
    }

    public NumberOfCalls(int field) {
        this.field = field;
    }

    @Override
    public int hashCode() {
        System.out.println("In Hashcode method.");
        return 10;
    }

    @Override
    public boolean equals(Object obj) {
        System.out.println("In Equals Method");
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        NumberOfCalls other = (NumberOfCalls) obj;
        if (field != other.field)
            return false;
        return true;
    }

    public static void main(String[] args) {
        NumberOfCalls object1 = new NumberOfCalls(5);
        NumberOfCalls object2 = new NumberOfCalls(6);
        NumberOfCalls object3 = new NumberOfCalls(5);
        Set<NumberOfCalls> set = new HashSet<NumberOfCalls>();
        set.add(object1);
        set.add(object2);
        Iterator<NumberOfCalls> it = set.iterator();
        System.out.print("Size of set is : " + set.size()
            + "\nObject fields values present in set are : ");
        while (it.hasNext()) {
            System.out.print(it.next().getField() + "   ");
        }
        System.out.println("\n---------------------------------------------------");
        System.out.println("Now checking number of calls -- ");
        System.out.println("Object1 is present in set ? - " + set.contains(object1)+"\n");
        System.out.println("Object2 is present in set ? - " + set.contains(object2)+"\n");
        System.out.println("Object3 is present in set ? - " + set.contains(object3)+"\n");
    }
}

以上代码的输出是

In Hashcode method.
In Hashcode method.
In Equals Method
Size of set is : 2
Object fields values present in set are : 6 5

---------------------------------------------------
Now checking number of calls --
In Hashcode method.
In Equals Method
Object1 is present in set ? - true

In Hashcode method.
Object2 is present in set ? - true

In Hashcode method.
In Equals Method
In Equals Method
Object3 is present in set ? - true

问题：

为什么 hashCode() 和 equals() 在 object1 而不是 object2 的情况下调用一次（在这种情况下仅调用 hashCode()）？
为什么 equals() 在 object3 的情况下被调用两次？

Answer 1

当您将元素添加到 Set 时，它会在内部存储在 Map 中，其中键是您传入的对象，值设置为 null。内部 Map 维护一个链表数组（桶）。这些数组也可以称为桶。使用 hashCode() 方法评估存储桶的索引。

在您的情况下，由于 hashCode() returns 是一个常量值，所以放入 Set 的所有值都将放入同一个桶中。所以对于第一次调用 set.add(object1) 内部结构将类似于

bucket [object1 -> null]

由于每个桶都包含一个链表，存储在链表中的元素有一个指向下一个元素的指针。由于列表中只添加了一个元素，因此指针指向 null.

下次调用 set.add(object2) 数据结构将如下所示

bucket [object2 -> object1 -> null]

现在每当您调用 set.contains(some_object) 时，都会调用 hashCode() 来找出正确的存储桶。此调用还 returns 引用第一个元素。

第一个问题的答案：

所以当你调用 set.contains(object2) 时，它实际上 returns 引用了 object2。现在，如果您查看 HashMap class' 代码，它首先使用 == 运算符比较此引用是否与传入的引用相同。因为在这种情况下它是相同的所以它不调用 equals() 方法。下面是来自 HashMap class:

的代码片段

if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;

这应该可以解释您的第一个问题。

第二个问题的答案：

当您调用 set.contains(object3) 时，会计算存储桶索引并返回对 object2 的引用。现在 object2 == object3 returns false 所以 Map 调用 object3.equals(object2) 方法（首先调用 equals() 方法）来检查两个对象是否有意义等价。这也是returnsfalse，所以它遍历list和returns引用到list中的下一个元素，也就是object1.

同样 object1 == object3 returns false 所以 Map 调用 object3.equals(object1)（第二次调用 equals() 方法）方法来检查两个对象是否有意义等价。

这导致对 equals() 方法的 2 次调用。

如果 hashcode returns 是常量值，在 HashSet.contains() 情况下调用 hashCode() 和 equals() 的次数

Number of calls of hashCode() and equals() in case of HashSet.contains() if hashcode returns a constant value

java

hashcode