Java中==和equals()为啥不一样？一篇讲透底层区别

本文深入解析了Java中`==`操作符与`equals()`方法的本质区别，旨在帮助开发者彻底理解其底层差异和应用场景。`==`主要用于比较基本数据类型的值或引用类型的内存地址，而`equals()`方法默认比较内存地址，但通常会被重写以实现对象内容的比较。文章详细阐述了重写`equals()`方法的必要性、最佳实践，以及为何重写`equals()`时也要重写`hashCode()`方法，以保证对象在哈希表中的正确使用。此外，还探讨了在何种情况下可以使用`==`替代`equals()`，例如比较基本类型、枚举或单例对象。通过本文，读者将能够清晰区分`==`和`equals()`，并在实际开发中做出正确的选择，提升代码质量和程序效率。

Java中==和equals()的底层区别在于：1. ==操作符比较的是基本数据类型的值或引用类型的内存地址；2. equals()默认比较内存地址，但可被重写以比较对象内容。例如，String类重写了equals()以比较字符串内容。因此，当需要根据对象属性判断相等时需重写equals()，同时也要重写hashCode()以保持一致性。此外，使用==适用于基本类型、枚举、单例对象或性能关键场景。

简单来说，== 比较的是内存地址，而 equals() 方法默认比较的也是内存地址（除非被重写），但通常会被重写用于比较对象的内容。

深入比较Java中==和equals()的底层区别

== 操作符和 equals() 方法，初学者很容易混淆。但实际上，它们在Java中扮演着截然不同的角色。== 就像一把尺子，直接测量两个变量指向的内存地址是否相同；而 equals() 方法则更像一个自定义的比较器，它允许我们根据对象的内容来判断它们是否相等。

Java中，== 和 equals() 的最根本区别是什么？

== 操作符，对于基本数据类型（如 int、float、char 等），比较的是它们的值是否相等。但对于引用类型（如 String、自定义的类等），比较的是两个引用是否指向内存中的同一个对象。换句话说，它比较的是两个对象的内存地址。

equals() 方法则不同。它是 Object 类中的一个方法，这意味着所有的Java对象都继承了该方法。默认情况下，equals() 方法的行为与 == 相同，也是比较两个对象的内存地址。但是，equals() 方法可以被重写（override），以便根据对象的内容来判断它们是否相等。

例如，String 类就重写了 equals() 方法，使得它可以比较两个字符串的内容是否相同，而不仅仅是比较它们的内存地址。这就是为什么我们可以用 string1.equals(string2) 来判断两个字符串是否相等，即使它们是不同的对象。

为什么需要重写equals()方法？什么时候应该重写？

想象一下，你创建了一个 Person 类，其中包含 name 和 age 两个属性。如果你创建了两个 Person 对象，它们的 name 和 age 都相同，但它们是内存中不同的对象。此时，使用 == 比较这两个对象将返回 false，因为它们的内存地址不同。

但是，从业务逻辑上讲，我们可能认为这两个 Person 对象是相等的，因为它们具有相同的属性值。为了实现这种逻辑，我们需要重写 Person 类的 equals() 方法，使其比较两个对象的 name 和 age 属性是否相等。

一般来说，当你需要根据对象的内容来判断它们是否相等时，就应该重写 equals() 方法。这通常发生在自定义的类中，特别是那些表示数据实体或值的类。

重写equals()方法时，有哪些最佳实践？

重写 equals() 方法时，需要遵循一些重要的约定，以确保其行为符合预期且避免潜在的错误：

1. 自反性（Reflexivity）： 对于任何非空对象 x，x.equals(x) 必须返回 true。
2. 对称性（Symmetry）： 对于任何非空对象 x 和 y，如果 x.equals(y) 返回 true，那么 y.equals(x) 也必须返回 true。
3. 传递性（Transitivity）： 对于任何非空对象 x、y 和 z，如果 x.equals(y) 返回 true 且 y.equals(z) 返回 true，那么 x.equals(z) 也必须返回 true。
4. 一致性（Consistency）： 对于任何非空对象 x 和 y，如果对象中用于 equals() 比较的信息没有被修改，那么无论调用多少次 x.equals(y)，其返回值必须保持一致。
5. 非空性（Non-nullity）： 对于任何非空对象 x，x.equals(null) 必须返回 false。

此外，重写 equals() 方法时，通常也需要同时重写 hashCode() 方法。这是因为 hashCode() 方法用于计算对象的哈希码，而哈希码在哈希表等数据结构中被广泛使用。如果两个对象通过 equals() 方法判断为相等，那么它们的哈希码也必须相等。

下面是一个重写 Person 类的 equals() 和 hashCode() 方法的示例：

import java.util.Objects;

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

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

在这个示例中，我们使用了 Objects.equals() 方法来比较 name 属性，并使用 Objects.hash() 方法来计算哈希码。这些方法可以帮助我们避免空指针异常，并简化代码。

String类的equals()方法是如何实现的？为什么这么实现？

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类型，或者长度不相等，则认为不相等
}

这么实现的原因主要有以下几点：

• 语义明确： String 对象代表一个文本字符串，比较内容是否相等是最符合直觉的语义。用户通常期望 equals() 方法比较的是字符串的值，而不是内存地址。
• 性能考虑： 首先比较对象引用，如果相同则直接返回 true，这是一个快速的优化。然后比较字符串长度，如果长度不同，则肯定不相等，避免了不必要的字符比较。最后逐个字符比较，确保内容完全一致。
• 不可变性： String 类是不可变的，这意味着一旦创建，其内容就不能被修改。这使得 equals() 方法的实现更加简单和可靠，因为不需要担心字符串内容在比较过程中发生变化。

为什么重写 equals() 方法通常也要重写 hashCode() 方法？

hashCode() 方法和 equals() 方法之间存在着重要的联系。Java 规范规定，如果两个对象通过 equals() 方法判断为相等，那么它们的 hashCode() 方法必须返回相同的值。

这个规定的原因是为了确保哈希表等数据结构的正确性。哈希表使用哈希码来确定对象在表中的位置。如果两个相等的对象具有不同的哈希码，那么它们可能会被放置在哈希表的不同位置，导致无法正确地检索到对象。

因此，当你重写 equals() 方法时，通常也需要重写 hashCode() 方法，以确保相等的对象具有相同的哈希码。一个常见的做法是使用对象中用于 equals() 比较的属性来计算哈希码。

什么时候可以使用 == 而不是 equals()？

虽然通常情况下，我们应该使用 equals() 方法来比较对象的内容，但在某些情况下，使用 == 也是可以的：

• 比较基本数据类型： 对于基本数据类型，== 比较的是它们的值是否相等，这是正确的行为。
• 比较枚举类型： 枚举类型保证只有一个实例，因此可以使用 == 来比较两个枚举常量是否相同。
• 比较单例模式的对象： 单例模式保证只有一个实例，因此可以使用 == 来比较两个对象是否是同一个实例。
• 性能至上的场景： 如果你非常确定比较的两个对象是同一个实例，并且性能是关键因素，那么可以使用 == 来避免调用 equals() 方法的开销。但需要谨慎使用，确保逻辑的正确性。

总而言之，== 和 equals() 在 Java 中扮演着不同的角色。== 比较的是内存地址，而 equals() 方法用于比较对象的内容。在大多数情况下，我们应该使用 equals() 方法来比较对象的内容，并且在重写 equals() 方法时，需要遵循一些重要的约定，并同时重写 hashCode() 方法。

理论要掌握，实操不能落！以上关于《Java中==和equals()为啥不一样？一篇讲透底层区别》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！