Android面试-Java 中 hashCode 与 equals 的区别:从原理到实践

0 阅读5分钟

​

 一、为什么要把 hashCode 和 equals 放在一起讨论

在 Java 中,equals 和 hashCode 都定义在 java.lang.Object 类中,看起来是两个独立的方法,但它们之间存在一条非常重要的约定:如果两个对象通过 equals 判断相等,那么它们的 hashCode 必须相等。这条约定直接决定了对象在 HashMap、HashSet、HashTable 等基于哈希的集合中能否被正确存取。

很多线上问题,比如“明明放进去的对象却取不出来”“Set 里出现了重复元素”,根源往往就是只重写了 equals 而没有重写 hashCode,或者两者逻辑不一致。

二、equals 的作用与默认行为

equals 用于判断两个对象在逻辑上是否相等。Object 类中的默认实现是:

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

也就是说,默认情况下 equals 比较的是引用地址,等价于 ==。对于业务对象,我们通常希望“内容相同即相等”,因此需要重写 equals。

重写 equals 需要满足以下五个特性:

  • 自反性:x.equals(x) 必须为 true。
  • 对称性:x.equals(y) 为 true 时,y.equals(x) 也必须为 true。
  • 传递性:x.equals(y) 且 y.equals(z) 为 true,则 x.equals(z) 也必须为 true。
  • 一致性:只要参与比较的属性没有改变,多次调用结果应保持一致。
  • 非空性:x.equals(null) 必须返回 false。

三、hashCode 的作用与默认行为

hashCode 返回一个 int 类型的哈希值,主要用于哈希表快速定位元素所在的“桶”。Object 的默认实现通常是把对象的内存地址转换为一个整数(具体由 JVM 实现决定)。

重写 hashCode 需要满足:

  • 在同一个程序运行期间,只要参与 equals 比较的属性没有改变,多次调用 hashCode 必须返回相同的值。
  • 如果 a.equals(b) 为 true,则 a.hashCode() == b.hashCode() 必须成立。
  • 如果 a.equals(b) 为 false,a.hashCode() 与 b.hashCode() 允许相同,这属于哈希冲突,是正常现象。

四、两者的核心区别对比

对比维度equalshashCode
返回值类型booleanint
作用判断两个对象逻辑上是否相等计算对象的哈希值,用于哈希表定位
默认实现比较引用地址(等价于 ==)基于对象内存地址等信息生成
性能通常较慢,需要逐个比较属性通常较快,一次计算即可定位桶
使用场景业务判等、集合去重判断HashMap、HashSet、ConcurrentHashMap 等
重写要求满足自反、对称、传递、一致、非空equals 相等则 hashCode 必须相等

五、哈希集合中的协作流程

以 HashMap 的 get 操作为例,查找过程大致如下:

flowchart TD
    A[调用 get key] --> B[计算 key.hashCode]
    B --> C[通过扰动与取模定位桶]
    C --> D{桶是否为空}
    D -->|是| E[返回 null]
    D -->|否| F[遍历桶内节点]
    F --> G{hash 是否相同}
    G -->|否| H[继续下一个节点]
    G -->|是| I{equals 是否为 true}
    I -->|否| H
    I -->|是| J[返回对应 value]
    H --> F

可以看到,hashCode 负责快速缩小范围,equals 负责最终精确判定。两者是“先粗筛、后精判”的协作关系。

六、只重写 equals 不重写 hashCode 会怎样

假设有一个 User 类,只重写了 equals:

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }
}

此时执行下面的代码:

Set<User> set = new HashSet<>();
set.add(new User("Tom", 18));
System.out.println(set.contains(new User("Tom", 18))); // false

结果是 false。原因是两个对象的 hashCode 不同,被放到了不同的桶里,contains 根本不会走到 equals 比较那一步。这就是最典型的“equals 相等但取不出来”的问题。

七、正确的同时重写方式

推荐使用 Objects.equals 和 Objects.hash 简化实现:

import java.util.Objects;

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }

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

如果使用 Lombok,可以直接标注 @EqualsAndHashCode,它会自动生成一致的实现。使用 IDE 的“Generate equals() and hashCode()”功能也是常见做法。

八、实践中的注意事项

  1. 成对重写:重写 equals 就必须重写 hashCode,反之亦然,保持逻辑一致。
  2. 参与计算的字段要一致:hashCode 使用的字段应当是 equals 比较字段的子集,通常完全一致。
  3. 避免可变字段:如果对象作为 HashMap 的 key 后修改了参与哈希计算的字段,会导致再也找不到该元素。
  4. 不要用可变对象做 key:优先使用 String、Integer 等不可变类型作为 key。
  5. 性能考虑:hashCode 会被频繁调用,尽量使用高效且分布均匀的算法,避免大量哈希冲突退化为链表遍历。
  6. 继承场景:子类重写 equals 时要注意对称性,必要时使用 getClass() 而非 instanceof 判断类型。

九、总结

equals 解决的是“两个对象是否相等”的语义问题,hashCode 解决的是“对象在哈希表中放在哪里”的性能问题。二者不是替代关系,而是协作关系:hashCode 负责快速定位,equals 负责精确比较。牢记“equals 相等则 hashCode 必须相等”这条铁律,并在重写时保持两者字段一致,才能避免哈希集合中的各种隐蔽 Bug。

使用小程序,查看更多面试题目,随时随地刷题,刷题更方便!

gh_1760057d7fd9_258 (3).jpg

​