前言：Java面试中，==和equals的区别绝对是“出场率TOP3”的基础题，但90%的人只答得出“==比地址，equals比内容”，一追问就翻车！今天不聊基础废话，只讲面试加分点、底层原理和实际开发坑，结合代码示例讲透，帮你在面试官面前拉开差距，轻松拿下offer🔥

一、先破后立：别再死记“表面区别”

很多面试者一上来就说“==比较基本类型值、引用类型地址；equals比较内容”，这句话没错，但太浅了！面试官真正想考察的是：你是否懂底层实现、是否踩过实际开发中的坑、是否能结合场景灵活运用。

先抛核心结论（记准，面试直接用）：

1. == 是Java内置运算符，底层比较的是“值”——但这个“值”分两种情况（重点！）；

2. equals() 是Object类的方法，底层默认和==一样比地址，但可被重写，重写后才会比较“内容”；

3. 关键坑点：重写equals()不重写hashCode()，会导致HashMap、HashSet等集合操作失效（面试必问延伸点）。

二、底层拆解：==的“双重标准”（带代码示例）

==的作用逻辑很简单，但容易被忽略“引用类型的特殊场景”，直接上代码，结合内存分析，一看就懂：

public class EqualsTest {
    public static void main(String[] args) {
        // 场景1：基本数据类型（byte、short、int、long、float、double、char、boolean）
        int a = 10;
        int b = 10;
        System.out.println(a == b); // 输出true，比较的是“值”
        
        // 场景2：引用数据类型（对象、数组、字符串等）
        String s1 = new String("java面试");
        String s2 = new String("java面试");
        System.out.println(s1 == s2); // 输出false，比较的是“内存地址”
        
        // 场景3：引用类型的特殊情况（常量池复用）
        String s3 = "java面试";
        String s4 = "java面试";
        System.out.println(s3 == s4); // 输出true，因为常量池复用，地址相同
    }
}

重点解析（面试加分话术）：

- 基本数据类型没有“对象”概念，存在栈内存中，==直接比较栈中的值，没任何歧义；

- 引用数据类型的变量，栈中存的是“对象的内存地址”，堆中存的是对象本身，==比较的是栈中的“地址值”，和堆中对象的内容无关；

- String的常量池复用（s3和s4），是JVM的优化机制，面试时能说出这一点，比单纯说“==比地址”更显专业（延伸：Integer的缓存机制也类似，-128~127范围内会复用常量）。

三、深度剖析：equals()的“底层逻辑+重写陷阱”

很多人以为equals()天生就比“内容”，其实不然！我们先看Object类中equals()的源码（面试能背出来更加分）：

// Object类的equals()默认实现
public boolean equals(Object obj) {
    return (this == obj); // 本质还是用==比较地址！
}

也就是说：如果一个类（比如自定义类）没有重写equals()，那么它的equals()和==完全一样，都是比较地址！

3.1 常见类的重写逻辑（String、Integer）

String类重写了equals()，核心是“比较字符串的字符序列”，看源码片段（简化版）：

// String类重写的equals()
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true; // 先判断地址，相同直接返回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的equals()）：

String s1 = new String("java面试");
String s2 = new String("java面试");
System.out.println(s1.equals(s2)); // 输出true，比较内容
System.out.println(s1 == s2); // 输出false，比较地址

3.2 重写equals()的“致命陷阱”（面试高频追问）

面试中，面试官常会追问：“重写equals()时，为什么必须重写hashCode()？” 很多人答不上来，其实结合HashMap的底层逻辑就很好理解，直接上反例：

// 自定义实体类（未重写hashCode()）
class User {
    private String id;
    private String name;

    // 重写equals()，比较id和name是否相同
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) && Objects.equals(name, user.name);
    }

    // 未重写hashCode()，使用Object的默认实现（基于地址）
    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public static void main(String[] args) {
        User u1 = new User("1001", "张三");
        User u2 = new User("1001", "张三");
        
        System.out.println(u1.equals(u2)); // 输出true（内容相同）
        
        // 放入HashMap中
        Map<User, String> map = new HashMap<>();
        map.put(u1, "java工程师");
        System.out.println(map.get(u2)); // 输出null，预期应该是“java工程师”
    }
}

问题原因（面试精准回答）：

HashMap的底层是“哈希表”，查找key时会先通过hashCode()计算哈希值，定位到对应的桶位置，再通过equals()比较内容；

上述代码中，u1和u2的equals()返回true，但未重写hashCode()，Object的默认hashCode()基于内存地址，u1和u2的hashCode()不同，会被定位到不同的桶，所以get(u2)找不到u1存入的值。

正确做法（重写equals()必须重写hashCode()）：

@Override
public int hashCode() {
    // 基于equals()中用到的字段（id和name）计算哈希值，保证equals()为true的对象，hashCode()一定相同
    return Objects.hash(id, name);
}

补充原则（面试必背）：equals()相等的两个对象，hashCode()必须相等；hashCode()相等的两个对象，equals()不一定相等（比如“通话”和“重地”，hashCode()相同，但equals()不同）。

四、面试实战：高频追问及标准回答（直接套用）

光懂原理不够，还要会应对面试官的追问，整理了3个高频追问，附标准回答，帮你直接加分：

追问1：Integer a = 127，Integer b = 127，a==b为true；a=128，b=128，a==b为false，为什么？

回答：因为Integer有缓存机制，JVM会缓存-128~127范围内的Integer对象，当赋值在这个范围内时，会直接复用缓存中的对象，地址相同，所以==返回true；超过这个范围，会新建Integer对象，地址不同，==返回false；如果要比较内容，无论范围，都用equals()。

追问2：重写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(y)，结果必须一致；⑤ 非空性：x.equals(null)必须返回false。

追问3：实际开发中，什么时候需要重写equals()和hashCode()？

回答：当自定义类需要“按内容判断是否相等”时，比如实体类（User、Order），尤其是当这些类的对象要作为HashMap、HashSet的key时，必须同时重写equals()和hashCode()，否则会导致集合操作失效。

五、总结（面试速记版）

1. ==：基本类型比“值”，引用类型比“地址”；

2. equals()：默认比“地址”，重写后比“内容”；

3. 坑点：重写equals()必重写hashCode()，否则集合操作出问题；

4. 加分点：能说出String常量池、Integer缓存机制、HashMap底层关联逻辑。

最后：这道题看似基础，但能拉开新手和有经验开发者的差距。记住，面试时不要只说表面区别，结合底层源码、代码示例和实际坑点，才能让面试官眼前一亮！

关注我（直奔標竿），后续持续更新Java高频面试题深度解析，全是面试加分干货，助力你直奔大厂目标🏆