Java 中 equals 方法的重写

简介

在 Java 编程里，equals 方法是一个至关重要的方法，它主要用于比较两个对象是否相等。不过，Object 类里的 equals 方法默认仅比较对象的引用，也就是判断两个对象是否为同一个实例。在很多情形下，我们需要依据对象的内容来判断它们是否相等，这就需要对 equals 方法进行重写。本文会深入探讨 equals 方法重写的基础概念、使用方法、常见实践以及最佳实践。

基础概念

在 Java 中，所有类都继承自 Object 类，而 Object 类里定义了 equals 方法，其默认实现如下：

public boolean equals(Object obj) {
    return (this == obj);
}

这个默认实现只是简单地比较两个对象的引用是否相同，也就是判断它们是否指向内存中的同一个对象。但在实际开发中，我们通常需要比较对象的内容是否相等，例如比较两个 Person 对象的姓名和年龄是否相同。这时就需要重写 equals 方法。

使用方法

要重写 equals 方法，需要遵循以下步骤： 1. 检查引用是否相同：首先检查两个对象的引用是否相同，如果相同则直接返回 true。 2. 检查对象是否为 null：检查传入的对象是否为 null，如果为 null 则返回 false。 3. 检查对象类型：使用 instanceof 关键字检查传入的对象是否为当前类或其子类的实例，如果不是则返回 false。 4. 强制类型转换：将传入的对象强制转换为当前类的类型。 5. 比较对象的属性：比较当前对象和传入对象的属性是否相等。

以下是一个重写 equals 方法的示例：

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;
        }
        // 检查对象是否为 null
        if (obj == null) {
            return false;
        }
        // 检查对象类型
        if (!(obj instanceof Person)) {
            return false;
        }
        // 强制类型转换
        Person other = (Person) obj;
        // 比较对象的属性
        return this.name.equals(other.name) && this.age == other.age;
    }
}

可以使用以下代码测试重写的 equals 方法：

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 20);
        Person p2 = new Person("Alice", 20);
        Person p3 = new Person("Bob", 25);

        System.out.println(p1.equals(p2)); // 输出: true
        System.out.println(p1.equals(p3)); // 输出: false
    }
}

常见实践

处理 `null` 值

在比较对象的属性时，需要注意处理 null 值。例如，如果 name 属性可能为 null，则需要在比较时进行额外的检查：

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (!(obj instanceof Person)) {
        return false;
    }
    Person other = (Person) obj;
    if (this.name == null) {
        if (other.name != null) {
            return false;
        }
    } else if (!this.name.equals(other.name)) {
        return false;
    }
    return this.age == other.age;
}

与 `hashCode` 方法保持一致

在重写 equals 方法时，通常也需要重写 hashCode 方法。这是因为 Java 中的 HashMap、HashSet 等集合类在存储对象时会使用 hashCode 方法来确定对象的存储位置，如果 equals 方法和 hashCode 方法不一致，可能会导致集合类的行为不符合预期。

以下是重写 hashCode 方法的示例：

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

最佳实践

使用 `Objects.equals` 方法

Java 7 引入了 java.util.Objects 类，其中的 equals 方法可以简化 null 值的处理。可以使用 Objects.equals 方法来比较对象的属性：

import java.util.Objects;

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (!(obj instanceof Person)) {
        return false;
    }
    Person other = (Person) obj;
    return Objects.equals(this.name, other.name) && this.age == other.age;
}

遵循 `equals` 方法的契约

重写 equals 方法时，需要遵循以下契约： 1. 自反性：对于任何非 null 的引用值 x，x.equals(x) 必须返回 true。 2. 对称性：对于任何非 null 的引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 必须返回 true。 3. 传递性：对于任何非 null 的引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 必须返回 true。 4. 一致性：对于任何非 null 的引用值 x 和 y，多次调用 x.equals(y) 必须始终返回相同的结果，前提是对象上的比较信息没有被修改。 5. 非空性：对于任何非 null 的引用值 x，x.equals(null) 必须返回 false。

小结

重写 equals 方法是 Java 编程中的一个常见需求，通过重写 equals 方法可以根据对象的内容来判断它们是否相等。在重写 equals 方法时，需要注意处理 null 值，与 hashCode 方法保持一致，遵循 equals 方法的契约。使用 Objects.equals 方法可以简化 null 值的处理，提高代码的可读性和健壮性。

参考资料

Effective Java（第三版），Joshua Bloch 著