equals 与 hashCode

举报
yd_227606267 发表于 2026/10/20 10:49:39 2026/10/20
【摘要】 equals 与 hashCode:契约、源码与 HashMap 中的真实作用重写 equals 却忘了 hashCode,对象放进 HashSet 后就再也取不出来。这类问题不会在编译期报错,只会在运行时以"数据丢失"的形式出现。本文从 Object 的默认实现讲起,结合 String 源码和 HashMap 的定位逻辑,说明契约为什么必须成对满足,并列出实际项目中最容易踩的几种情况。 ...

equals 与 hashCode:契约、源码与 HashMap 中的真实作用

重写 equals 却忘了 hashCode,对象放进 HashSet 后就再也取不出来。这类问题不会在编译期报错,只会在运行时以"数据丢失"的形式出现。

本文从 Object 的默认实现讲起,结合 String 源码和 HashMap 的定位逻辑,说明契约为什么必须成对满足,并列出实际项目中最容易踩的几种情况。

Object 提供的默认行为

Object.equals 的实现就是引用比较:

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

Object.hashCode 是 native 方法,返回对象头中的 identity hash code。HotSpot 默认使用 Marsaglia xor-shift 算法生成,首次调用时写入对象头的 Mark Word,之后保持不变。

因此不重写时,“相等"等价于"同一个对象”。== 对基本类型比较值,对引用比较地址;equals 可以被重写,语义由实现者决定。

契约的五条与三条

equals 必须满足:

  • 自反性:x.equals(x) 为 true。
  • 对称性:x.equals(y) 与 y.equals(x) 结果一致。
  • 传递性:x.equals(y) 且 y.equals(z),则 x.equals(z)。
  • 一致性:只要参与比较的状态没变,多次调用结果不变。
  • 非空性:x.equals(null) 恒为 false。

hashCode 必须满足:

  • 同一次运行中,只要 equals 用到的信息没变,hashCode 必须返回相同值。
  • equals 相等的两个对象,hashCode 必须相等。
  • equals 不等的两个对象,hashCode 允许相等(哈希碰撞),但应尽量分散。

第三条是"允许"而不是"必须不同",这给实现留了余地,也意味着哈希碰撞是正常现象,集合必须用 equals 做最终判定。

String.hashCode 为什么用 31

JDK 8 的源码:

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

选 31 的理由有三点:它是奇素数,乘法可以被 JIT 优化为 (h << 5) - h;数值不大,累乘时溢出频率较低(溢出本身无害,int 自然回绕);实践中分布较均匀。代价是存在已知碰撞,例如 "Aa" 与 "BB" 的哈希值都是 2112。

hash 字段缓存结果,第二次调用直接返回,这也是 String 作为 HashMap key 高效的原因之一。

在 HashMap 中的实际作用

HashMap 的定位分两步:先用 hashCode 找桶,再用 equals 在桶内比较。JDK 8 的扰动函数:

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

索引计算是 (n - 1) & hash,只用到低位,把高 16 位异或到低位可以让高位也参与,减少规律性 key 的碰撞。

put 的简化流程是:表为空先扩容;计算索引;桶为空直接放入;桶首节点 key 相等则覆盖;是树节点走红黑树;否则遍历链表,尾部插入,链表长度达到 8 且容量不小于 64 时树化,否则扩容。

由此可以得出:hashCode 不同,equals 根本不会被调用;hashCode 相同而 equals 为 false,才会形成链表。只重写 equals 不重写 hashCode,两个"相等"的对象会落到不同桶里,集合既查不到也删不掉。

正确的重写方式

public final class User {
    private final long id;
    private final String name;

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof User)) {
            return false;
        }
        User other = (User) o;
        return id == other.id && Objects.equals(name, other.name);
    }

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

要点:先判引用相等快速返回;用 instanceof 兼容子类;基本类型用 ==,引用类型用 Objects.equals;hashCode 用 Objects.hash,内部是 31 倍累加。

参与计算的字段应当是不可变且能标识对象的组合,通常选业务主键,而不是全部字段。

JDK 16 起可以用 record 自动生成 equals、hashCode、toString,基于所有组件,适合纯值对象。

复合主键的写法

业务中经常需要"订单号 + 商品 ID"这样的复合 key。用字符串拼接是常见做法,但分隔符选择不当会碰撞:"a" + "-" + "b-c" 与 "a-b" + "-" + "c" 都得到 a-b-c。

更稳妥的是定义一个不可变的 key 类,或用 record(JDK 16+):

public record OrderItemKey(String orderNo, long skuId) {}

record 自动生成基于全部组件的 equals 与 hashCode,且字段 final,作为 Map key 不会因为后续修改而失效。JDK 8 环境可以手写一个 final 类,或在明确不会碰撞时使用 List.of(orderNo, skuId) 这类不可变列表作为 key——List 的 equals 与 hashCode 都按元素定义。

需要特别注意,Arrays.asList 返回的列表虽然结构不可变(不能增删),但 set 会修改元素,仍可能破坏哈希值。

compareTo 与 equals 必须一致

实现了 Comparable 的类,compareTo 返回 0 的语义应当与 equals 返回 true 一致。TreeMap 和 TreeSet 只用 compareTo 判断元素是否相同,根本不会调用 equals 和 hashCode。

class Version implements Comparable<Version> {
    private final int major;
    private final int minor;
    // 只比较 major,忽略 minor
    public int compareTo(Version o) { return Integer.compare(major, o.major); }
}

上面的实现里,1.0 和 1.5 在 TreeSet 中被视为同一个元素,后者会被丢弃,而 HashSet 中它们共存。这种不一致会让同一份数据在不同集合里表现出不同结果,排查时极其困难。

BigDecimal 是 JDK 中一个已知的例外:compareTo 忽略 scale,equals 比较 scale,官方文档明确说明了这一点。把 BigDecimal 放进 TreeMap 和 HashMap 会得到不同的去重结果,工程上应避免把它作为集合 key,或先统一精度。

常见坑

  1. 可变字段参与 hashCode。对象放进 HashSet 后修改字段,哈希值变化,remove 和 contains 都会失败。
Set<User> set = new HashSet<>();
User u = new User(1L, "a");
set.add(u);
u.setName("b");        // 若 name 参与 hashCode
System.out.println(set.contains(u)); // false

在 HashMap 中这类条目会变成"幽灵条目",只能遍历删除。

  1. equals 参数写成具体类型。public boolean equals(User o) 是重载而不是重写,集合仍然调用 Object.equals。加上 @Override 可以让编译器直接报错。

  2. 继承破坏对称性。父类用 instanceof,子类增加字段后,父.equals(子) 为 true 而 子.equals(父) 为 false。Lombok 的 @EqualsAndHashCode 默认 callSuper = false,父类字段被忽略,需要时显式写 @EqualsAndHashCode(callSuper = true)。

  3. 数组字段。数组的 equals 和 hashCode 都是 identity 语义,必须用 Arrays.equals 与 Arrays.hashCode。

  4. BigDecimal 的 scale。new BigDecimal("1.0").equals(new BigDecimal("1.00")) 为 false,但 compareTo 为 0。作为 Map key 时会出现"明明数值相同却取不到",应统一 stripTrailingZeros 或改用字符串。

  5. 依赖包装类缓存。Integer 在 -128 到 127 之间复用缓存对象,== 恰好为 true,超出范围就是 false,不要把它当作值比较。

最佳实践

  • 值对象优先用 record 或不可变类,从源头消除可变 key 的问题。
  • equals 只比较身份字段,hashCode 与之严格一致,不要包含更新时间之类的易变字段。
  • 高频作为 key 且字段 final 的对象,可以手工缓存 hashCode,避免每次遍历字段。
  • 用 IDE 或 Lombok 生成后,review 一遍字段列表,确认没有漏掉新增字段。
  • 需要排序语义时实现 Comparable,并保证 compareTo 为 0 与 equals 为 true 一致。TreeMap 用 compareTo 判等,二者不一致会导致元素被"吞掉"。
  • 集合元素一旦入桶就不要再修改参与哈希的字段,确需修改时先 remove、改完再 add。
  • 对第三方类无法改源码时,用 HashMap 包装成以业务主键为 key 的结构,而不是强行依赖原类的 equals。

小结

  • Object 默认的 equals 是引用比较,hashCode 是对象头中的 identity hash。
  • 契约核心是"equals 相等则 hashCode 必须相等",违反后对象在哈希集合中不可检索。
  • String 用 31 作为乘子并缓存 hash,HashMap 用 h ^ (h >>> 16) 扰动后再取模。
  • 可变字段、继承、数组、BigDecimal 的 scale 是最常见的四类问题。
  • 能用不可变值对象或 record 解决,就不要手写 equals 和 hashCode。
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。