跳转至

深入理解 Java 中的 equals() 和 hashCode()

简介

在 Java 编程中，equals() 和 hashCode() 是 Object 类的两个重要方法。它们在对象比较、集合操作等方面起着关键作用。正确理解和使用这两个方法对于编写高质量、高效的 Java 代码至关重要。本文将详细介绍这两个方法的基础概念、使用方法、常见实践以及最佳实践。

目录

  1. 基础概念
    • equals() 方法
    • hashCode() 方法
  2. 使用方法
    • 重写 equals() 方法
    • 重写 hashCode() 方法
  3. 常见实践
    • 在自定义类中使用 equals() 和 hashCode()
    • 在集合中的应用
  4. 最佳实践
    • 遵循约定
    • 一致性和性能
  5. 小结
  6. 参考资料

基础概念

equals() 方法

equals() 方法用于比较两个对象是否相等。在 Object 类中，equals() 方法的默认实现是比较两个对象的内存地址，即只有当两个对象是同一个对象时才返回 true。

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

然而，在实际应用中，我们通常希望根据对象的内容来判断是否相等。例如，两个表示相同日期的 Date 对象，即使它们在内存中的地址不同，也应该被认为是相等的。

hashCode() 方法

hashCode() 方法返回一个整数，用于表示对象的哈希码。哈希码在哈希表（如 HashMap 和 HashSet）等数据结构中起着重要作用。哈希表通过对象的哈希码来快速定位对象，从而提高查找效率。

在 Object 类中，hashCode() 方法返回一个基于对象内存地址的唯一值。

public native int hashCode();

不同的对象通常会有不同的哈希码，但也可能会出现哈希冲突（即不同对象返回相同的哈希码）。

使用方法

重写 equals() 方法

当我们需要根据对象的内容来比较对象时，需要重写 equals() 方法。重写时需要遵循以下几个原则： 1. 自反性：对于任何非空引用 x，x.equals(x) 应该返回 true。 2. 对称性：对于任何非空引用 x 和 y，x.equals(y) 为 true 当且仅当 y.equals(x) 为 true。 3. 传递性：对于任何非空引用 x、y 和 z，如果 x.equals(y) 为 true 且 y.equals(z) 为 true，那么 x.equals(z) 也应该为 true。 4. 一致性：对于任何非空引用 x 和 y，多次调用 x.equals(y) 应该始终返回相同的结果，前提是对象的内容没有发生变化。 5. 非空性：对于任何非空引用 x，x.equals(null) 应该返回 false。

下面是一个重写 equals() 方法的示例：

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 other = (Person) obj;
        return age == other.age && name.equals(other.name);
    }
}

重写 hashCode() 方法

如果重写了 equals() 方法，通常也需要重写 hashCode() 方法，以保证两个相等的对象具有相同的哈希码。这是因为在哈希表中，首先会根据对象的哈希码来定位桶位置，然后再通过 equals() 方法来进一步比较对象是否相等。

重写 hashCode() 方法时，应该尽量保证不同的对象返回不同的哈希码，以减少哈希冲突。一个常见的实现方式是使用对象的属性来计算哈希码。

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 other = (Person) obj;
        return age == other.age && name.equals(other.name);
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + name.hashCode();
        result = 31 * result + age;
        return result;
    }
}

常见实践

在自定义类中使用 equals() 和 hashCode()

在自定义类中，我们通常需要根据业务需求重写 equals() 和 hashCode() 方法。例如，在一个表示商品的类中，我们可能希望根据商品的名称和价格来判断两个商品是否相等。

public class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass()!= obj.getClass()) {
            return false;
        }
        Product other = (Product) obj;
        return Double.compare(other.price, price) == 0 && name.equals(other.name);
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = name.hashCode();
        temp = Double.doubleToLongBits(price);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
}

在集合中的应用

在 HashSet 和 HashMap 等基于哈希的集合中，equals() 和 hashCode() 方法起着关键作用。当向 HashSet 中添加对象时，首先会计算对象的哈希码，然后根据哈希码找到对应的桶位置。如果桶中已经有对象，再通过 equals() 方法来判断是否是重复对象。

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

public class Main {
    public static void main(String[] args) {
        Set<Person> personSet = new HashSet<>();
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Alice", 25);

        personSet.add(person1);
        personSet.add(person2);

        System.out.println(personSet.size()); // 输出 1，因为 person1 和 person2 被认为是相等的
    }
}

最佳实践

遵循约定

重写 equals() 和 hashCode() 方法时，一定要严格遵循前面提到的约定。否则，可能会导致在集合中出现意外的行为，例如对象无法正确添加或查找。

一致性和性能

在计算哈希码时，要尽量保证不同对象的哈希码差异较大，以减少哈希冲突。同时，也要注意计算哈希码的性能，避免使用过于复杂的计算方法。

小结

equals() 和 hashCode() 是 Java 中非常重要的方法，它们在对象比较和集合操作中起着关键作用。正确重写这两个方法可以确保程序的正确性和性能。在实际开发中，我们需要根据业务需求仔细考虑如何重写这两个方法，并遵循相关的约定和最佳实践。

参考资料