==和 equals 的区别是什么？-Java面试题-PHP中文网

==和 equals 的区别是什么？

煙雲

发布： 2025-07-10 18:46:02

原创

828人浏览过

==比较内存地址，equals比较内容（若重写）。1. ==操作符对基本类型比较值，引用类型比较地址。2. equals默认行为与==相同，但可被重写以比较对象内容。3. 重写equals时必须同时重写hashcode以保持一致性，确保相等对象哈希码相同。4. string类重写equals以比较字符数组内容。5. 哈希码用于快速定位哈希表中对象位置，未重写hashcode会导致集合类如hashmap无法正确识别相等对象。

==和 equals 的区别是什么？

简单来说，== 比较的是内存地址，而 equals 比较的是对象的内容，但前提是 equals 方法被正确地重写过。

解决方案

== 和 equals 是 Java 中用于比较的两种方式，但它们的比较对象和比较内容有着本质的区别。理解它们的区别对于编写正确的 Java 代码至关重要。

== 操作符：

比较的是变量所指向的内存地址。
对于基本数据类型（如 int, char, boolean 等），== 比较的是它们的值。例如，int a = 5; int b = 5; a == b 的结果是 true。
对于引用类型（如 String, Object 等），== 比较的是它们在内存中的地址。即使两个对象的内容完全相同，但如果它们是不同的对象，== 的结果仍然是 false。

equals 方法：

equals 方法是 Object 类中定义的方法，所有 Java 类都继承自 Object 类，因此都具有 equals 方法。
默认情况下，equals 方法的行为与 == 相同，即比较的是对象的内存地址。
但是，equals 方法可以被重写（override），以便根据对象的内容进行比较。例如，String 类就重写了 equals 方法，使得它可以比较两个字符串的内容是否相同。

什么时候应该重写 equals 方法？

当你需要比较两个对象的内容是否相等，而不是比较它们是否是同一个对象时，就应该重写 equals 方法。比如，你有一个 Person 类，包含 name 和 age 属性。如果你希望当两个 Person 对象的 name 和 age 都相同时，就认为它们相等，那么你就需要重写 equals 方法。

一个简单的 Person 类的 equals 方法示例：

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

    // 构造函数、getter 和 setter 方法省略

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

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

登录后复制

注意，重写 equals 方法时，通常也需要重写 hashCode 方法，以保证 equals 方法和 hashCode 方法的一致性。如果两个对象 equals 返回 true，那么它们的 hashCode 值必须相同。反之，如果两个对象的 hashCode 值不同，那么它们的 equals 方法必须返回 false。

String 类的 equals 方法为什么比较的是内容？

String 类重写了 equals 方法。 String 类将字符串的内容存储在字符数组中，equals 方法比较的是这两个字符数组中的每个字符是否都相同。这也是为什么即使两个 String 对象是不同的对象，但如果它们包含相同的字符序列，equals 方法也会返回 true。

String str1 = new String("hello");
String str2 = new String("hello");

System.out.println(str1 == str2); // 输出 false，因为 str1 和 str2 是不同的对象
System.out.println(str1.equals(str2)); // 输出 true，因为 str1 和 str2 的内容相同

String str3 = "hello";
String str4 = "hello";

System.out.println(str3 == str4); // 输出 true，因为字符串常量池的优化，str3 和 str4 指向同一个对象
System.out.println(str3.equals(str4)); // 输出 true，因为 str3 和 str4 的内容相同

登录后复制

HashCode 的作用是什么？为什么重写 equals 的时候需要重写 HashCode？

魔乐社区

天翼云和华为联合打造的AI开发者社区，支持AI模型评测训练、全流程开发应用

102

查看详情

hashCode 方法返回对象的哈希码，它是一个整数值，用于在哈希表（如 HashMap, HashSet 等）中快速查找对象。

快速查找： 哈希表使用哈希码来确定对象在表中的存储位置。当需要查找对象时，哈希表首先计算对象的哈希码，然后根据哈希码快速定位到对象可能存在的桶（bucket）。
唯一性： 理想情况下，不同的对象应该产生不同的哈希码，但实际上，由于哈希函数的限制，可能会出现哈希冲突，即不同的对象产生相同的哈希码。

重写 equals 方法时，必须同时重写 hashCode 方法，以保证 equals 方法和 hashCode 方法的一致性。这是因为哈希表依赖于 hashCode 方法来确定对象的存储位置，如果两个对象 equals 返回 true，但它们的 hashCode 值不同，那么它们在哈希表中会被存储在不同的位置，导致无法正确查找。

假设你只重写了 equals 方法，而没有重写 hashCode 方法，那么两个 equals 返回 true 的对象仍然会有不同的哈希码。当你将这两个对象放入 HashMap 中时，HashMap 会认为它们是不同的对象，并将它们存储在不同的位置。当你尝试使用其中一个对象来获取 HashMap 中的值时，HashMap 可能会找不到该对象，导致程序出错。

例如：

import java.util.HashMap;
import java.util.Map;

public class HashCodeTest {

    static class Student {
        int id;
        String name;

        public Student(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Student student = (Student) obj;
            return id == student.id && name.equals(student.name);
        }

        // 缺少 hashCode 方法
    }

    public static void main(String[] args) {
        Student s1 = new Student(1, "Alice");
        Student s2 = new Student(1, "Alice");

        Map<Student, String> map = new HashMap<>();
        map.put(s1, "Alice's Info");

        System.out.println(map.get(s2)); // 期望输出 "Alice's Info"，但实际输出 null
    }
}

登录后复制

在这个例子中，s1 和 s2 的 equals 方法返回 true，但由于没有重写 hashCode 方法，它们有不同的哈希码。当你尝试使用 s2 从 HashMap 中获取值时，HashMap 会根据 s2 的哈希码找到一个不同的位置，导致无法找到 s1 对应的值，最终返回 null。

如何正确重写 hashCode 方法？

重写 hashCode 方法的目标是为相等的对象生成相同的哈希码，为不相等的对象生成不同的哈希码（尽量）。

以下是一些常用的重写 hashCode 方法的技巧：

使用对象的关键属性： 选择对象的关键属性，这些属性用于确定对象的相等性。
使用 Objects.hash() 方法： Objects.hash() 方法可以方便地为多个属性生成哈希码。
使用质数： 在计算哈希码时，可以使用质数来减少哈希冲突。

例如，对于上面的 Person 类，可以这样重写 hashCode 方法：

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

登录后复制

总结

== 比较的是内存地址，而 equals 比较的是对象的内容（在 equals 方法被重写的情况下）。当你需要比较两个对象的内容是否相等时，应该重写 equals 方法，并同时重写 hashCode 方法，以保证 equals 方法和 hashCode 方法的一致性。理解 == 和 equals 的区别对于编写正确的 Java 代码至关重要，特别是当涉及到集合类（如 HashMap, HashSet 等）时。

以上就是==和 equals 的区别是什么？的详细内容，更多请关注php中文网其它相关文章！