Java中==与equals()的用法及区别总结

在Ja va编程中，==和equals()的区别，堪称面试官的“心头好”，也是新手开发者最容易踩坑的地方之一。今天，我们就来彻底讲透这两个操作，让你不仅知其然，更知其所以然。

先记住一句核心口诀：== 判断“是不是同一个”，equals() 判断“长得像不像”。 这里的“像不像”，完全取决于类有没有重写equals()方法。

核心区别对比

为了让你一目了然，我们先把最关键的区别列出来：

== 的用法：简单直接

作为运算符，==的行为非常明确。

基本类型比较：比的就是值

对于int, char, double等基本类型，==直接比较它们的数值是否相等。

int a = 10;
int b = 10;
System.out.println(a == b); // true

char c1 = 'A';
char c2 = 'B';
System.out.println(c1 == c2); // false

引用类型比较：比的是内存地址

对于对象引用，==比较的是两个引用变量是否指向堆内存中的同一个对象。

String s1 = new String("Ja va");
String s2 = new String("Ja va");
String s3 = s1;

System.out.println(s1 == s2); // false（不同对象）
System.out.println(s1 == s3); // true（同一引用）

equals() 的用法：可定制的“相等”

equals()是Object类的一个方法，它的行为可以被重写。

默认行为：和 == 一样

如果你去看Object.equals()的源码，会发现它其实非常简单：

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

没错，默认情况下，equals()就是调用了==，比较地址。

重写后的行为：比的是内容

许多常用的Ja va类，比如String、Integer，都重写了equals()方法，使其比较对象的内容是否相等。

String s1 = new String("Ja va");
String s2 = new String("Ja va");

System.out.println(s1.equals(s2)); // true（比较字符串内容）

进阶高频考点（建议必背）

掌握了基础，下面这些是面试中经常被深挖的点。

字符串常量池（String Pool）

这是String类特有的机制，也是面试常客。为什么同样是字符串比较，==有时对有时错？

String a = "abc"; // 字面量，放入常量池
String b = "abc"; // 指向常量池中同一个对象
String c = new String("abc"); // new 关键字，在堆上创建新对象

System.out.println(a == b);       // true（常量池同一对象）
System.out.println(a == c);       // false（堆上不同对象）
System.out.println(a.equals(c));  // true（内容相等）

补充一个方法intern()，它可以将字符串对象放入常量池（如果池中还没有的话），并返回池中的引用。

String d = c.intern();
System.out.println(a == d); // true（intern 返回常量池引用）

包装类缓存机制（Integer Cache）

为了提升性能，Ja va为部分包装类（Integer, Short, Byte, Character, Long）设置了缓存。最典型的是Integer，默认缓存了-128到127之间的值。

Integer x = 127; // 自动装箱，从缓存取
Integer y = 127; // 同上，指向缓存中同一个对象
Integer m = 128; // 超出缓存范围，new Integer(128)
Integer n = 128; // 同上，new Integer(128)

System.out.println(x == y);      // true  （缓存范围内，同一对象）
System.out.println(m == n);      // false （缓存范围外，不同对象）
System.out.println(m.equals(n)); // true  （值相等）

结论：比较包装类型的值，优先用 equals()。或者，你也可以先拆箱成基本类型再用==，但要小心null拆箱会引发NullPointerException。

equals()与hashCode()的契约（HashMap/HashSet 面试点）

这是集合框架的基石，必须理解。

• 契约：如果两个对象通过equals()比较是相等的，那么它们的hashCode()返回值必须相同。反之则不一定。
• 集合流程：HashMap或HashSet在查找元素时，会先调用hashCode()定位到大致位置（桶），再调用equals()进行精确匹配。
• 只重写equals()的后果：如果两个对象逻辑相等（equals()为true）但hashCode()不同，它们可能会被放入集合的不同位置，导致“放得进去，但用equals()判断为相等的对象却取不出来”的诡异现象。

equals()正确重写规则（契约）

自己重写equals()时，必须遵守以下五个数学契约：

1. 自反性：x.equals(x) 必须为 true。
2. 对称性：x.equals(y) 为 true 则 y.equals(x) 也为 true。
3. 传递性：x.equals(y)、y.equals(z) 为 true 则 x.equals(z) 必须为 true。
4. 一致性：对象状态不变时，多次调用结果一致。
5. 非空性：x.equals(null) 必须为 false。

instanceof还是getClass()？（加分点）

在重写equals()时，如何判断类型？这里有个经典选择：

• getClass()：要求必须是同一个具体类的实例才可能相等。这种方式更严格，不容易破坏对称性和传递性。
• instanceof：允许子类对象与父类对象进行比较，更灵活。但在复杂的继承体系中，如果子类增加了新的影响相等性的字段，很容易无意中破坏契约。

通常，如果类不是为继承而设计的（比如用final修饰），或者你希望精确控制相等性，使用getClass()更安全。

null安全：避免 NPE 的写法

调用equals()时，一个常见的陷阱是空指针异常。

容易出错的写法

String s = null;
System.out.println(s.equals("a")); // 抛出 NullPointerException

推荐的写法

将已知的非空对象放在前面：

String s = null;
System.out.println("a".equals(s)); // false，安全

或者使用Ja va 7引入的工具类：

System.out.println(ja va.util.Objects.equals(s, "a")); // false（null-safe）

一个规范的重写示例（可背模板）

下面是一个符合契约、且考虑了hashCode()的完整重写模板，可以直接套用：

import ja va.util.Objects;

public class Person {
    private final String name;
    private final int age;

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

    @Override
    public boolean equals(Object o) {
        // 1. 自反性：检查是否同一个对象
        if (this == o) return true;
        // 2. 非空性 & 类型检查
        if (o == null || getClass() != o.getClass()) return false;
        // 3. 类型转换
        Person person = (Person) o;
        // 4. 关键字段比较（使用Objects.equals处理null）
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        // 使用相同的字段生成hashCode
        return Objects.hash(name, age);
    }
}

什么时候用==？什么时候用equals()？（面试收尾）

最后，我们来做个清晰的总结，帮你快速决策：

• 基本类型：直接用 ==。
• 判断两个引用是否指向同一对象：用 ==。
• 判断对象内容（业务逻辑相等）：用 equals()（前提是类已正确重写）。
• 比较 enum 常量：推荐使用 ==。因为枚举值是单例，==不仅安全，而且语义更明确，性能也更好。

常见追问补充

面试官可能还会顺着问下去，这里也准备了一些答案：

1. StringBuilder / StringBuffer：它们没有重写equals()方法，比较的仍是地址。要比较内容，先调用toString()转成String再比。
2. 数组：数组是对象，但其equals()方法没有重写，比较的是地址。要比较数组内容，请使用Arrays.equals()（一维数组）或Arrays.deepEquals()（多维数组）。
3. 浮点数比较：由于精度问题，对float或double使用==判断相等可能不可靠。业务上通常比较它们的差值是否在一个极小的误差范围（epsilon）内。

总结

说到底，==和equals()的区别，核心在于比较的“维度”不同。前者是物理层面的“身份”比较，后者是逻辑层面的“内容”比较。理解这个根本区别，再结合字符串常量池、包装类缓存这些特定场景，以及重写equals()时必须遵守的契约和配套的hashCode()，你就能彻底掌握这个Ja va基础中的关键考点了。