Java面试必问：==与equals区别及hashCode契约详解

1. 为什么Java面试总爱问==和equals的区别？

这个问题几乎出现在90%的Java初级面试中，但很多开发者依然会在实际编码中混淆。根本原因在于对对象内存模型的理解不彻底。

1.1 ==运算符的本质

==比较的是栈内存中的值，对于基本类型直接比较数值，对于引用类型比较的是堆内存地址。例如：

java复制String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false

这里会输出false，因为new关键字在堆中创建了两个不同地址的对象。

关键理解：所有new操作都会在堆中开辟新内存空间，==比较的就是这个内存地址值。

1.2 equals方法的契约

Object类中equals默认实现就是==比较，但Java强烈建议重写此方法。以String类为例，其equals实现如下：

java复制public boolean equals(Object anObject) {
    if (this == anObject) return true;
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i]) return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

可以看到String比较的是字符序列内容而非内存地址。

1.3 开发中的经典误用

最常见的错误是在自定义类中忘记重写equals。比如：

java复制class Person {
    String name;
    // 缺少equals重写
}

Person p1 = new Person("张三");
Person p2 = new Person("张三");
System.out.println(p1.equals(p2)); // false

这会导致集合类操作出现意外行为，比如HashSet.contains()可能返回错误结果。

2. hashCode契约的深层逻辑

2.1 hashCode的三重约定

1. 一致性：对象内容未变时，多次调用应返回相同值
2. 相等性：两个对象equals为true时，hashCode必须相同
3. 不等性：equals为false时，hashCode尽量不同（非强制）

2.2 HashMap的工作原理

HashMap通过hashCode确定桶位置，再用equals确认键值对。典型冲突场景：

java复制class BrokenKey {
    int id;
    
    @Override
    public boolean equals(Object o) {
        // 正确实现
    }
    // 未重写hashCode
}

Map<BrokenKey, String> map = new HashMap<>();
map.put(new BrokenKey(1), "value");
map.get(new BrokenKey(1)); // 返回null

这是因为两个相同id的对象产生了不同hashCode，导致查找时定位到错误桶。

2.3 最佳实现模式

Effective Java推荐的hashCode实现公式：

java复制@Override
public int hashCode() {
    int result = Integer.hashCode(field1);
    result = 31 * result + Arrays.hashCode(field2);
    result = 31 * result + Objects.hashCode(field3);
    return result;
}

使用31的原因：

• 奇素数，减少hash冲突
• JVM自动优化为位运算：31 * i = (i << 5) - i

3. 接口与抽象类的抉择

3.1 语法特性对比

3.2 设计模式中的应用差异

策略模式通常使用接口：

java复制interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardPayment implements PaymentStrategy {}
class AlipayPayment implements PaymentStrategy {}

模板方法模式则适合用抽象类：

java复制abstract class DataExporter {
    // 固定算法骨架
    public final void export() {
        prepareData();
        formatData();
        writeFile();
    }
    
    protected abstract void formatData();
}

3.3 JDK8后的接口演进

默认方法的引入使接口也能提供行为复用：

java复制interface Logger {
    default void log(String message) {
        System.out.println("[INFO] " + message);
    }
}

但要注意"菱形继承"问题：

java复制interface A { default void foo(){} }
interface B { default void foo(){} }
class C implements A, B {} // 编译错误

4. 深拷贝与浅拷贝的实战陷阱

4.1 浅拷贝的内存模型

Object.clone()默认实现是浅拷贝：

java复制class Person implements Cloneable {
    String name;
    Address address;
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }
}

此时拷贝对象与原对象共享address引用，修改任意一方都会影响另一方。

4.2 深拷贝实现方案

方案一：递归clone

java复制@Override
protected Object clone() {
    Person cloned = (Person)super.clone();
    cloned.address = (Address)address.clone();
    return cloned;
}

方案二：序列化法（应对复杂对象图）

java复制public static <T> T deepCopy(T obj) throws IOException, ClassNotFoundException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(obj);
    
    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);
    return (T) ois.readObject();
}

4.3 不可变对象的最佳实践

对于深度不可变对象，可以避免拷贝开销：

java复制class ImmutablePerson {
    private final String name;
    private final Address address; // Address也需不可变
    
    public ImmutablePerson(String name, Address address) {
        this.name = name;
        this.address = new Address(address.getDetail()); // 防御性拷贝
    }
    
    public Address getAddress() {
        return new Address(this.address.getDetail()); // 返回拷贝
    }
}

5. 面试实战技巧

5.1 回答框架建议

采用"定义→区别→应用场景→注意事项"的结构：

1. 先明确概念定义
2. 对比核心差异点
3. 举例说明适用场景
4. 补充易错点和最佳实践

5.2 高频追问问题

面试官可能进一步追问：

• HashMap如何处理hash冲突？
• 为什么重写equals必须重写hashCode？
• 抽象类能否没有抽象方法？
• 深拷贝有哪些性能优化方案？

5.3 代码演示技巧

在白板编码时注意：

java复制// 演示equals重写时
@Override  // 显式标注
public boolean equals(Object o) {  // 参数必须是Object
    if (this == o) return true;  // 自反性优化
    if (o == null || getClass() != o.getClass()) return false; // 类型检查
    // 字段比较...
}

6. 从原理到实践的思考

在实际项目代码审查中，我发现最容易出现问题的场景是：

1. 实体类重写了equals却忘记hashCode，导致HashMap行为异常
2. 滥用继承导致抽象类膨胀，其实应该拆分为接口组合
3. 浅拷贝对象被意外修改引发的并发问题

一个经验法则：当需要定义行为契约时优先选择接口，当需要复用公共代码时考虑抽象类。对于不可变对象，深度防御性拷贝往往比事后克隆更安全可靠。