equals和hashCode

为什么重写equals还要重写hashCode方法，详细说明

在Java中，如果你重写了 equals 方法，通常也需要重写 hashCode 方法。这是因为 equals 和 hashCode 方法在 Java 集合框架（如 HashMap、HashSet 和 Hashtable）中扮演着重要的角色。以下是详细的解释：

1. equals 方法的作用

equals 方法用于比较两个对象是否相等。默认的 equals 方法（从 Object 类继承）比较的是对象的引用，即两个对象是否指向同一个内存地址。

当你需要自定义相等的定义时，比如两个对象的内容相同就认为它们相等，就需要重写 equals 方法。例如：

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    MyClass myClass = (MyClass) obj;
    return field1.equals(myClass.field1) && field2.equals(myClass.field2);
}

2. hashCode 方法的作用

hashCode 方法返回对象的哈希码，它是一个整数，用于在哈希表（如 HashMap、HashSet 等集合）中快速定位对象，能够转换成唯一的索引值。哈希码是根据对象的内容生成的，用于提高集合的性能。

3. equals 和 hashCode 的关系

equals 和 hashCode 方法在使用哈希表时有一定的关系。如果两个对象相等（根据 equals 方法的定义），它们必须具有相同的哈希码。这是因为哈希表使用哈希码来快速定位对象，如果两个相等的对象有不同的哈希码，那么它们在哈希表中的位置可能不同，从而导致错误的结果或行为。

4. 合同（Contract）

Java 的 Object 类定义了 equals 和 hashCode 方法的合同（契约），即：

• 一致性：如果两个对象通过 equals 方法比较相等，那么它们的 hashCode 方法必须返回相同的值。
• 自反性：如果 a.equals(b) 为 true，则 b.equals(a) 必须为 true。
• 传递性：如果 a.equals(b) 和 b.equals(c) 都为 true，则 a.equals(c) 必须为 true。
• 对称性：a.equals(b) 的结果应该与 b.equals(a) 的结果一致。
• 一致性：如果对象的 equals 方法没有被修改，a.equals(b) 的结果应该一致。
• 非空性：a.equals(null) 应该返回 false。

5. 示例

假设我们有一个 Person 类，它重写了 equals 方法来根据姓名和年龄来判断相等：

public class Person {
    private String name;
    private int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

在这个例子中，hashCode 方法使用 Objects.hash(name, age) 来生成哈希码。这样确保了任何两个相等的 Person 对象具有相同的哈希码，从而维护了 hashCode 和 equals 的合同。

总结

重写 equals 方法时，重写 hashCode 方法是为了确保两个相等的对象具有相同的哈希码，这样可以保证哈希表的正确性和一致性。如果只重写了 equals 而不重写 hashCode，在使用哈希表时可能会出现意外的行为或错误。

如果不重写hashCode方法会有什么后果

如果在Java中重写了 equals 方法但没有相应地重写 hashCode 方法，会导致以下几个主要后果：

1. 哈希表的行为异常

Java 的哈希表类（如 HashMap、HashSet 和 Hashtable）依赖 hashCode 方法来快速定位对象。如果两个对象根据 equals 方法认为是相等的，但它们的 hashCode 方法返回不同的哈希码，这会导致这些对象在哈希表中被存储在不同的位置。

• 存储问题：例如，如果你向 HashSet 中添加两个相等的对象，由于它们的哈希码不同，HashSet 可能会将这两个对象存储在不同的桶中，从而导致集合中包含重复的对象。
• 查找问题：当你尝试从 HashMap 或 HashSet 中查找一个对象时，哈希表会使用对象的哈希码来确定其可能的位置。如果两个对象的哈希码不同，虽然它们在逻辑上是相等的（equals 方法返回 true），但查找操作可能找不到它们或返回错误的结果。

2. 集合操作的异常

以下是几个具体的操作示例：

• HashSet：如果你将两个根据 equals 方法相等的对象插入 HashSet，但它们的 hashCode 方法返回不同的哈希码，这两个对象将会被当作不同的对象存储，可能导致集合中存在重复的元素。

  Set<Person> set = new HashSet<>();
  Person p1 = new Person("Alice", 30);
  Person p2 = new Person("Alice", 30); // p1 和 p2 在逻辑上相等
  set.add(p1);
  set.add(p2); // 如果 p1 和 p2 的 hashCode 不同，它们可能都会被存储在集合中
  

• HashMap：如果你将两个相等的对象作为 HashMap 的键，并且它们的哈希码不同，后插入的键值对可能会覆盖先插入的键值对，从而导致不可预测的行为。

  Map<Person, String> map = new HashMap<>();
  Person p1 = new Person("Bob", 40);
  Person p2 = new Person("Bob", 40); // p1 和 p2 在逻辑上相等
  map.put(p1, "Value1");
  map.put(p2, "Value2"); // 如果 p1 和 p2 的 hashCode 不同，map 可能只保留其中一个条目
  

3. 违反集合类的合同

Java 集合类（如 HashSet、HashMap）的合同要求如果两个对象相等，则它们的哈希码必须相同。如果不遵守这一合同，可能会导致这些集合类的行为异常，破坏程序的逻辑一致性。

示例演示

以下是一个示例，演示了重写 equals 而不重写 hashCode 的后果：

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class Person {
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    // 没有重写 hashCode 方法
}

public class Main {
    public static void main(String[] args) {
        Set<Person> set = new HashSet<>();
        Person p1 = new Person("John", 25);
        Person p2 = new Person("John", 25);
        set.add(p1);
        set.add(p2);

        System.out.println("Set size: " + set.size()); // 可能输出 2，即使 p1 和 p2 应该相等
    }
}

在这个示例中，即使 p1 和 p2 应该被认为是相等的，但由于没有重写 hashCode 方法，它们可能被当作不同的对象，导致 HashSet 中有两个条目。

总结

如果重写了 equals 方法而没有重写 hashCode 方法，会导致哈希表操作的错误和不一致。这是因为 equals 和 hashCode 方法必须保持一致，以确保哈希表的正确行为和性能。为了避免这些问题，遵循 equals 和 hashCode 方法的合同是非常重要的。