相等契约救急锦囊： equals 与 hashCode

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

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;              // 同一个对象，短路提速
        if (!(o instanceof User u)) return false; // 类型不同直接 false（顺带处理了 null）
        return Objects.equals(id, u.id) && Objects.equals(name, u.name);
    }

    @Override
    public int hashCode() {
        // Objects.hash 按相同字段生成哈希，保证契约成立
        return Objects.hash(id, name);
    }
}

// 效果：new 出来的两个"内容相同"对象，也能在集合里互相找到
Set<User> users = new HashSet<>();
users.add(new User("S001", "张三"));
System.out.println(users.contains(new User("S001", "张三"))); // true

import java.util.HashMap;
import java.util.Map;

public class BrokenKeyDemo {
    // 错误写法：只重写 equals，不重写 hashCode
    static class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }

        @Override
        public boolean equals(Object o) {
            return o instanceof Point p && p.x == x && p.y == y;
        }
        // 没有 hashCode() —— 每个 new 出来的对象哈希值都不同
    }

    public static void main(String[] args) {
        Map<Point, String> map = new HashMap<>();
        map.put(new Point(1, 2), "目标值");

        System.out.println(map.get(new Point(1, 2))); // null！查不到
        // equals 判断"相等"的两个对象，因 hashCode 不同被分进不同桶
    }
}

// 一行顶上面 20 行，契约天然成立
public record User(String id, String name) {}

User a = new User("S001", "张三");
User b = new User("S001", "张三");
System.out.println(a.equals(b));          // true
Set<User> set = java.util.Set.of(a);
System.out.println(set.contains(b));      // true

// 经典事故：可变字段做 key
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class MutableKeyTrap {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a"));
        var set = new java.util.HashSet<List<String>>();
        set.add(list);

        list.add("b"); // 修改了参与 hashCode 计算的内容
        System.out.println(set.contains(list)); // false！对象还在集合里，却再也"找不到"
    }
}

Money a = new Money(1000, "CNY");
Money b = new Money(1000, "CNY");
System.out.println(a.equals(b));                    // 期望 true
System.out.println(a.hashCode() == b.hashCode());   // 期望 true
var set = new java.util.HashSet<Money>();
set.add(a);
System.out.println(set.contains(b));                // 期望 true——这才是契约生效

import java.util.Objects;

public class Money {
    private final long cents;      // 练习一先写死不可变，练习二再开放 setter
    private final String currency;

    public Money(long cents, String currency) {
        this.cents = cents;
        this.currency = currency;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;                       // 第一步：引用相同必相等
        if (obj == null || getClass() != obj.getClass())    // 第二步：null 与类型
            return false;
        Money other = (Money) obj;                          // 第三步：强转
        return this.cents == other.cents                    // 第四步：逐字段
            && Objects.equals(this.currency, other.currency);
    }

    @Override
    public int hashCode() {
        return Objects.hash(cents, currency);               // 与 equals 同字段
    }
}