为什么我需要覆盖 Java 中的 equals 和 hashCode 方法？

S

SebastianWilke

Joshua Bloch 谈有效的 Java

您必须在覆盖 equals() 的每个类中覆盖 hashCode()。不这样做将导致违反 Object.hashCode() 的一般约定，这将阻止您的类与所有基于哈希的集合（包括 HashMap、HashSet 和 Hashtable）一起正常运行。

让我们通过一个示例来理解它，如果我们覆盖 equals() 而不覆盖 hashCode() 并尝试使用 Map 会发生什么。

假设我们有一个这样的类，如果 importantField 相等，则 MyClass 的两个对象相等（eclipse 生成 hashCode() 和 equals()）

public class MyClass {
    private final String importantField;
    private final String anotherField;

    public MyClass(final String equalField, final String anotherField) {
        this.importantField = equalField;
        this.anotherField = anotherField;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((importantField == null) ? 0 : importantField.hashCode());
        return result;
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final MyClass other = (MyClass) obj;
        if (importantField == null) {
            if (other.importantField != null)
                return false;
        } else if (!importantField.equals(other.importantField))
            return false;
        return true;
    }
}

想象一下你有这个

MyClass first = new MyClass("a","first");
MyClass second = new MyClass("a","second");

仅覆盖 equals

如果只有 equals 被覆盖，那么当您首先调用 myMap.put(first,someValue) 时，将散列到某个存储桶，当您调用 myMap.put(second,someOtherValue) 时，它将散列到其他存储桶（因为它们有不同的 hashCode）。因此，尽管它们是相等的，但由于它们没有散列到同一个桶，因此映射无法实现，它们都留在映射中。

虽然如果我们覆盖 hashCode() 就没有必要覆盖 equals()，让我们看看在这种特殊情况下会发生什么，我们知道 MyClass 的两个对象如果它们的 importantField 相等但我们不覆盖它们是相等的equals()。

仅覆盖 hashCode

如果您只覆盖 hashCode，那么当您调用 myMap.put(first,someValue) 时，它首先会计算其 hashCode 并将其存储在给定的存储桶中。然后，当您调用 myMap.put(second,someOtherValue) 时，它应该根据 Map Documentation 将 first 替换为 second，因为它们是相等的（根据业务要求）。

但问题是 equals 没有重新定义，所以当映射散列 second 并遍历存储桶查看是否有对象 k 使得 second.equals(k) 为真时，它不会找到任何对象，因为 second.equals(first) 会是false。

希望很清楚

您能否详细说明一下，在第二种情况下，为什么第二个对象必须放在另一个桶中？

我不喜欢这个答案，因为它表明你不能在不覆盖 equals() 的情况下覆盖 hashCode()，这根本不是真的。您说您的示例代码（“仅覆盖 hashCode”部分）不起作用，因为您将两个对象定义为相等，但是 - 抱歉 - 这个定义只是在你的脑海中。在您的第一个示例中，您有两个具有相同 hashCode 的不相等对象，这是完全合法的。所以你需要重写equals()的原因不是因为你已经重写了hashCode()，而是因为你想把你的“等于”定义从你的头脑中移到代码中。

if you think you need to override one, then you need to override both of them 是错误的。如果您的类覆盖 equals 但反向不正确，则需要覆盖 hashCode。

我认为完全只覆盖 hashCode() 而不覆盖 equals() 是完全可以的。它也是用 Effective Java 编写的：books.google.fr/…

@PhantomReference，请注意，仅覆盖 equals 会违反 Object 的 javadoc 中规定的约定：“如果根据 equals(Object) 方法两个对象相等，则在每个对象上调用 hashCode 方法两个对象中的一个必须产生相同的整数结果。” 当然，并非所有合约的所有部分都在所有代码中执行，但从形式上讲，这是一种违规行为，我认为这是一个等待发生。

r

rajeev pani..

HashMap 和 HashSet 等集合使用对象的 hashcode 值来确定应如何将其存储在集合中，并按顺序再次使用 hashcode在其集合中定位对象。

哈希检索是一个两步过程：

找到正确的桶（使用 hashCode()）在桶中搜索正确的元素（使用 equals() ）

这是一个关于为什么我们应该覆盖 equals() 和 hashcode() 的小示例。

考虑一个具有两个字段的 Employee 类：年龄和姓名。

public class Employee {

    String name;
    int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this)
            return true;
        if (!(obj instanceof Employee))
            return false;
        Employee employee = (Employee) obj;
        return employee.getAge() == this.getAge()
                && employee.getName() == this.getName();
    }

    // commented    
    /*  @Override
        public int hashCode() {
            int result=17;
            result=31*result+age;
            result=31*result+(name!=null ? name.hashCode():0);
            return result;
        }
     */
}

现在创建一个类，将 Employee 对象插入 HashSet 并测试该对象是否存在。

public class ClientTest {
    public static void main(String[] args) {
        Employee employee = new Employee("rajeev", 24);
        Employee employee1 = new Employee("rajeev", 25);
        Employee employee2 = new Employee("rajeev", 24);

        HashSet<Employee> employees = new HashSet<Employee>();
        employees.add(employee);
        System.out.println(employees.contains(employee2));
        System.out.println("employee.hashCode():  " + employee.hashCode()
        + "  employee2.hashCode():" + employee2.hashCode());
    }
}

它将打印以下内容：

false
employee.hashCode():  321755204  employee2.hashCode():375890482

现在取消注释 hashcode() 方法，执行相同的操作，输出将是：

true
employee.hashCode():  -938387308  employee2.hashCode():-938387308

现在你能明白为什么如果两个对象被认为相等，那么它们的 hashcode 也必须相等吗？否则，您将永远无法找到该对象，因为 Object 类中的默认 hashcode 方法实际上总是为每个对象提供一个唯一编号，即使 equals() 方法在此类中被覆盖一种将两个或多个对象视为相等的方式。如果对象的 hashcode 没有反映这一点，那么对象的平等程度并不重要。所以再来一次：如果两个对象相等，那么它们的 hashcode 也必须相等。

@rajeev我有一个困惑，当我们在HashMap的情况下覆盖hashCode方法时，为什么我们需要覆盖equals方法？在任何情况下，如果对象的哈希码相等，则 hashmap 会替换该值。

@VikasVerma equals 对象将具有相等的哈希码并不意味着不相等的对象将具有不相等的哈希码。如果对象实际上不同，但它们的哈希码相同怎么办？

有什么理由在 hashcode() 实现中使用这些数字（17 和 31）来生成哈希码？我们可以使用任何随机数吗？

@JavaYouth 是的，你可以

@JavaYouth ，正如 Rajeev 所提到的，您可以使用任何其他值。但是，建议使用素数，因为这样会产生更少的冲突。

l

likejudo

您必须在覆盖 equals() 的每个类中覆盖 hashCode()。不这样做将导致违反 Object.hashCode() 的一般约定，这将阻止您的类与所有基于哈希的集合（包括 HashMap、HashSet 和 Hashtable）一起正常运行。来自 Effective Java，作者 Joshua Bloch

通过一致地定义 equals() 和 hashCode()，您可以提高类在基于哈希的集合中作为键的可用性。正如 hashCode 的 API 文档所解释的那样：“支持这种方法是为了便于使用 java.util.Hashtable 提供的哈希表。”

关于如何有效实施这些方法的问题的最佳答案是建议您阅读 Effective Java 的第 3 章。

这是正确答案。当然，如果您从不在基于哈希的集合中使用该类，那么您没有实现 hashCode() 也没关系。

在更复杂的情况下，您永远不知道您使用的集合是否使用哈希，因此请远离“您没有实现 hashCode() 并不重要”

我可以在不覆盖 equals() 的情况下覆盖 hashCode() 吗？

@Johnny当然你可以覆盖hascode而不覆盖equals。但是用例会是什么？

@Gi1ber7 从这里稍微检查一下我的答案，以分析了解 equals 和 hashCode 的 HashMap 和 HashTable 发生了什么

P