Java 中的 `==` 与 `equals()` 方法：对象内容比较与引用比较的细微差异

各位看官，大家好！今天咱们来聊聊 Java 这门语言里一对让人又爱又恨的好兄弟：== 和 equals()。它们都肩负着比较的重任，但比较的姿势和结果却大相径庭。就像一对双胞胎，长得挺像，脾气秉性却千差万别。搞清楚它们的区别，是成为 Java 大神的必经之路。否则，一不小心就会掉进坑里，debug 到天荒地老。

1. 别看我俩长得像，本质区别大着呢！

首先，我们要明确一点：== 和 equals() 比较的东西不一样。

==： 这位老兄比较的是引用（reference）。也就是说，它比较的是两个变量是否指向内存中的同一个对象。就像警察叔叔查身份证号码，如果两个人的身份证号码一样，那肯定就是同一个人了（在程序的世界里）。
equals()： 这位老弟比较的是对象的内容（content）。也就是说，它比较的是两个对象所包含的数据是否相同。就像咱们看两个人的照片，如果照片里的人长得一样，那我们就说他们长得像（当然，这只是比喻，程序可没这么智能，得你告诉它怎么比）。

为了更形象地理解，咱们可以把对象想象成房子，而变量就像房子的地址。

== 比较的是两个地址是否指向同一栋房子。如果是，那肯定就是同一栋房子了。
equals() 比较的是两栋房子里的装修风格和家具摆设是否一样。如果一样，那我们就说这两栋房子很相似。

2. 基本类型 vs. 引用类型：== 的特殊待遇

在 Java 的世界里，数据类型分为两大阵营：基本类型（primitive types）和引用类型（reference types）。 == 对待这两大阵营的态度可不一样。

基本类型： 对于 byte、short、int、long、float、double、char 和 boolean 这些基本类型，== 比较的是它们的值是否相等。这很好理解，就像比较两个数字的大小一样。
```
int a = 5;
int b = 5;
System.out.println(a == b); // 输出：true
```
引用类型： 对于对象、数组等引用类型，== 比较的是它们的引用（也就是内存地址）。
```
String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println(str1 == str2); // 输出：false
```
为什么是 false 呢？因为 str1 和 str2 虽然内容都是 "Hello"，但它们是两个不同的对象，存储在内存中的不同位置。

3. equals()：祖传秘方，需要你来调配

equals() 方法是 Object 类的一个成员方法，这意味着 Java 中所有的类都默认继承了 equals() 方法。默认情况下，equals() 方法的实现和 == 是一样的，也就是比较对象的引用。

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

但是，equals() 方法的强大之处在于它可以被重写（override）。也就是说，你可以根据自己的需求，定义 equals() 方法的比较规则。比如，你可以让 equals() 方法比较两个对象的某个或某些属性是否相等。

4. 重写 equals()：定制你的比较规则

重写 equals() 方法通常遵循以下步骤：

自反性（Reflexivity）： x.equals(x) 必须返回 true。任何对象都必须等于它自己。
对称性（Symmetry）： 如果 x.equals(y) 返回 true，那么 y.equals(x) 必须返回 true。
传递性（Transitivity）： 如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 必须返回 true。
一致性（Consistency）： 如果 x 和 y 没有被修改，那么多次调用 x.equals(y) 应该始终返回相同的结果。
与 null 的比较： x.equals(null) 必须返回 false。任何对象都不应该等于 null。

一个好的 equals() 方法应该满足以下条件：

类型检查： 首先判断传入的对象是否是当前类的实例。
null 检查： 判断传入的对象是否为 null。
属性比较： 比较对象的关键属性是否相等。

下面是一个重写 equals() 方法的例子：

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true; // 自反性
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false; // null 检查和类型检查
        }
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name); // 属性比较
    }

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

    public static void main(String[] args) {
        Person person1 = new Person("张三", 20);
        Person person2 = new Person("张三", 20);
        Person person3 = new Person("李四", 22);

        System.out.println(person1 == person2); // 输出：false (引用不同)
        System.out.println(person1.equals(person2)); // 输出：true (内容相同)
        System.out.println(person1.equals(person3)); // 输出：false (内容不同)
        System.out.println(person1.equals(null)); // 输出：false (与 null 比较)
    }
}

在这个例子中，我们重写了 Person 类的 equals() 方法，让它比较两个 Person 对象的 name 和 age 属性是否相等。如果两个 Person 对象的 name 和 age 属性都相等，那么我们就认为这两个 Person 对象是相等的。

5. hashCode()：equals() 的好搭档

在重写 equals() 方法的同时，通常也需要重写 hashCode() 方法。这是因为 Java 的一些集合类（如 HashMap、HashSet）会使用 hashCode() 方法来快速查找对象。

hashCode() 方法的作用是为对象生成一个哈希码（hash code）。哈希码是一个整数，用于标识对象。如果两个对象相等（根据 equals() 方法的定义），那么它们的哈希码必须相等。但是，如果两个对象的哈希码相等，它们不一定相等（这就是哈希冲突）。

一个好的 hashCode() 方法应该满足以下条件：

一致性（Consistency）： 如果对象没有被修改，那么多次调用 hashCode() 方法应该始终返回相同的值。
相等性（Equality）： 如果 x.equals(y) 返回 true，那么 x.hashCode() == y.hashCode() 必须返回 true。

如果只重写了 equals() 方法，而没有重写 hashCode() 方法，那么在使用 HashMap、HashSet 等集合类时，可能会出现一些意想不到的问题。

在上面的 Person 类中，我们还重写了 hashCode() 方法。我们使用了 Objects.hash() 方法来生成哈希码。 Objects.hash() 方法可以接受多个参数，并将它们组合成一个哈希码。这样可以确保如果两个 Person 对象的 name 和 age 属性都相等，那么它们的哈希码也相等。

6. String 类的特殊待遇

String 类是一个特殊的类。虽然 String 是一个引用类型，但是 String 类重写了 equals() 方法，让它比较的是字符串的内容。

String str1 = "Hello";
String str2 = "Hello";
System.out.println(str1 == str2); // 输出：true (字符串常量池)
System.out.println(str1.equals(str2)); // 输出：true (内容相同)

String str3 = new String("Hello");
String str4 = new String("Hello");
System.out.println(str3 == str4); // 输出：false (不同的对象)
System.out.println(str3.equals(str4)); // 输出：true (内容相同)

为什么第一个 == 的结果是 true 呢？这是因为 Java 有一个字符串常量池（string pool）。当我们使用字符串字面量（如 "Hello"）创建字符串时，Java 会首先在字符串常量池中查找是否已经存在相同的字符串。如果存在，就直接返回字符串常量池中的引用；如果不存在，就创建一个新的字符串，并将其添加到字符串常量池中。因此，str1 和 str2 指向的是字符串常量池中的同一个字符串对象。

而 str3 和 str4 使用 new String() 创建了新的字符串对象，因此它们指向的是内存中不同的对象。

7. equals() 和 hashCode() 的最佳实践

总是同时重写 equals() 和 hashCode() 方法。 如果只重写了 equals() 方法，而没有重写 hashCode() 方法，那么在使用 HashMap、HashSet 等集合类时，可能会出现一些意想不到的问题。
使用 Objects.equals() 和 Objects.hash() 方法。 这两个方法可以简化 equals() 和 hashCode() 方法的编写，并避免一些常见的错误。
确保 equals() 方法满足自反性、对称性、传递性、一致性和与 null 的比较等要求。
在 equals() 方法中进行类型检查和 null 检查。
只比较对象的关键属性。

8. 总结：== 和 equals() 的区别

为了方便大家记忆，我们用一张表格来总结一下 == 和 equals() 的区别：

特性	`==`	`equals()`
比较内容	引用（内存地址）	对象的内容（可以重写）
适用类型	基本类型和引用类型	引用类型
默认行为	比较引用	比较引用 (与 == 相同)
是否可重写	不可重写	可重写
String	对于字符串常量池中的字符串，比较引用	比较字符串的内容

9. 一些常见的坑

忘记重写 equals() 和 hashCode() 方法。 这会导致在使用 HashMap、HashSet 等集合类时出现问题。
在 equals() 方法中忘记进行类型检查和 null 检查。 这会导致 equals() 方法抛出异常或返回错误的结果。
在 equals() 方法中比较了不必要的属性。 这会导致 equals() 方法的性能下降。
错误地实现了 equals() 方法的对称性或传递性。 这会导致程序出现逻辑错误。

10. 最后的忠告

== 和 equals() 就像 Java 世界里的两把剑，用对了可以披荆斩棘，用错了就会伤到自己。希望通过今天的讲解，大家能够更加清楚地理解它们的区别，并在实际开发中灵活运用。记住，理解它们的本质，才能写出更加健壮和高效的代码。

好了，今天的分享就到这里。感谢大家的观看！如果觉得对您有所帮助，请点赞收藏，转发给更多的小伙伴。我们下期再见！

Java 中的 == 与 equals() 方法：对象内容比较与引用比较的细微差异

发表回复 取消回复

Java 中的 `==` 与 `equals()` 方法：对象内容比较与引用比较的细微差异

发表回复取消回复