搞懂 “ == ”和 equals 的区别！！！

最新推荐文章于 2025-06-17 09:18:27 发布

小王～同学

最新推荐文章于 2025-06-17 09:18:27 发布

阅读量394

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_45754055/article/details/118583316

Java 专栏收录该内容

27 篇文章

订阅专栏

这篇博客详细探讨了Java中`==`和`equals()`的区别，`==`主要比较对象的内存地址，而`equals()`默认比较对象引用，但在重写后可比较内容。文章还解释了为何在重写`equals()`时通常需要重写`hashCode()`方法，以确保一致性。未重写`hashCode()`可能导致散列集合中出现相等对象但哈希码不同的问题，影响集合的正常工作。最后，通过例子展示了重写前后的方法行为差异。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

学了这么久的Java，但是把 == 和 equals 还是经常搞混，今天就把它俩的区别搞搞清楚！！！

==:

它的作用是判断两个对象的地址是不是相等。即判断两个对象是不是同一个对象。

对于基本数据类型，== 比较的是值
对于引用数据类型，== 比较的是内存地址

equals():

它的作用也是判断两个对象是否相等。但它一般会有两种使用情况：

情况1：类没有覆写equals()方法。

通过equals()比较该类的对象时，等价于调用了Object类的equals()方法，也就是通过"=="比较这两个对象。

//Object类的equals方法
public boolean equals(Object obj) {
        return (this == obj);
}

情况2：类覆写了equals()方法。

覆写了equals方法，比较两个对象的内容是否相等，若内容相等，则返回true（认为这两个对象相等）

// String类中的equals() 方法，已覆盖，用于比较内容
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;
}

如果不重写equals()方法，会怎么样？

class Person{
    String name;
    public Person(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}
public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("小王");
        Person person2 = new Person("小王");
        /**
         * 没有重写equals()
         */
        System.out.println(person1 == person2);//false
        System.out.println(person1.equals(person2));//false
        // 由于没有重写equals()方法，此时这块调用的Object的equals()

        /**
         * 重写equals
         */
        System.out.println(person1.equals(person2));//true

        /**
         * String中的equals()方法是被重写过的equals()
         */
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);//在字符串常量池中，属于同一个对象，true
        System.out.println(s1.equals(s2));//true

        String s3 = new String("123");
        String s4 = new String("123");
        System.out.println(s3 == s4);//false
        System.out.println(s3.equals(s4));//true

        /**
         *StringBuffer中的没有重写equals，调用的是Object类的equals()方法
         * 相当于用”==”进行比较
         */
        StringBuffer c = new StringBuffer("小王");
        StringBuffer d = new StringBuffer("小王");
        System.out.println(c == d);//false
        System.out.println(c.equals(d));//false
    }
}

Object的equals方法比较的对象的内存地址；
String的equals方法比较的是对象的内容。

如果没有重写equals()方法，那么调用equals()方法，调用的就是Object类的equals()方法，相当于是用“==”比较。

重写equals的同时，我们需要重写hashCode()方法么？为什么？

在重写equals()方法时，也有必要对hashCode()方法进行重写，特别是自定义一个类，想把类的实例存储在集合中时。

equals()方法和hashCode()方法是java.lang.Object 类的两个重要的方法，Java中多数类都会重写Object类的equals()方法。

在实际应用中，如果自定义的类需要进行比较操作，就一定要重写equals()方法。那么为什么重写 equals()方法时，必须要求重写 hashCode() 方法呢？

equals()和hashCode() 方法之间的关系：

如果两个对象相同（equals比较返回true），那么它们的hashCode的值一定要相同；
如果两个对象的hashCode值相同，它们并不一定相同（用equals比较可能返回false）

《Effective java》一书中这样说到：在每个覆盖了 equals() 方法的类中，也必须覆盖 hashCode()方法，如果不这样做的话，就会违反 Object.hashCode的通用的约定，从而导致该类无法结合所有基于散列的集合一起正常运作，这样的集合包括HashMap，HashSet 和 HashTable。

重写 hashCode() 方法的原因，简单的说就是：
1.使用hashCode方法提前校验，可以避免每一次比对都调用equals方法，提高效率。

2.为了保证是同一个对象，在 equals 比较相同的情况下 hashCode值必定相同。如果重写了equals方法，而没有重写hashCode方法，会出现equals相等的对象，hashCode不相等的情况，重写hashCode方法就是为了避免这种情况的出现。

重写hashCode()方法的影响：

只重写equals()方法，不重写hashCode()方法

class Student{
   String name;
   int age;

    public Student(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;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
}
public class hashTest {
    public static void main(String[] args) {
        Student stu1 = new Student("xiaowang",19);
        Student stu2 = new Student("xiaowang",19);
        System.out.println("两位同学是同一个人吗？"+stu1 .equals(stu2));
        System.out.println("stu1.hashCode()="+stu1.hashCode());
        System.out.println("stu2.hahsCode()="+stu2.hashCode());
    }
}

结果：
在这里插入图片描述
如果重写了 equals() 而未重写 hashCode() 方法，可能就会出现两个没有关系的对象 equals 相同（因为equal都是根据对象的特征进行重写的），但 hashCode不相同的情况。
因为此时 Student 类的 hashCode方法就是 Object 默认的 hashCode方法，由于默认的 hashCode方法是根据对象的内存地址经哈希算法得来的，所以 stu1 != stu2，故两者的 hashCode值不一定相等。

根据hashCode的规则，两个对象相等其hash知一定是相等，所以就产生了矛盾。

在重写equals()时，也重写了hashCode()方法：

class Student{
   String name;
   int age;

    public Student(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;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
public class hashTest {
    public static void main(String[] args) {
        Student stu1 = new Student("xiaowang",19);
        Student stu2 = new Student("xiaowang",19);
        System.out.println("两位同学是同一个人吗？"+stu1 .equals(stu2));
        System.out.println("stu1.hashCode()="+stu1.hashCode());
        System.out.println("stu2.hahsCode()="+stu2.hashCode());
    }
}

执行结果：
在这里插入图片描述

如果我们在重写equals方法的同时，不对hashCode方法进行重写的话，默认地还是会使用Object类自带的hashCode方法，这样就会出现在某些情况下，明明两个对象的equals方法判断相等了，但是它们的hashCode居然不一样，这是不符合规范的。

hashCode经常用于散列数据的快速存取，例如在使用hash类数据集合时，都是先根据存储的对象的hashCode值去判断对象是否相同，因此如果不重写hashCode方法的话，会导致判断对象相同的时候，明明equals方法判断相等了，hashCode却判断不相等，就会造成在不同的位置中可以存放两个相同的对象，这就不合理了。