hashCode()和equals()方法的作用与区别_hashcode equals 方法的作用?-优快云博客

本文深入探讨了hashCode()和equals()方法的区别与联系，解析了两者在散列表中的作用及其实现原理，通过实例展示了如何正确重写这两个方法以确保对象在集合中的唯一性。

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

hashCode()和equals()方法的作用与区别

最近在研究HashMap的底层实现原理，源代码中的静态内部类Node类重写了hashCode()和equals()方法，虽然也大概知道这两个方法的作用，但是总感觉不透彻，所以专门做一个记录，来仔细探讨一下两者的区别和联系。文章内容主要来自以下两位大神博客，我做了简单的整理，原文链接如下：
https://www.cnblogs.com/skywang12345/p/3324958.html
https://blog.youkuaiyun.com/lijiecao0226/article/details/24609559

1. equals() 的作用

equals()方法定义在Object类中，主要用来比较两个对象是否相等，Object类中equals()方法的代码如下：

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

通过判断两个对象的地址是否一致来判断它们是否相等，既然比较的内容是两个对象的地址，也就是在判断这两个对象是否是同一个对象了。因为类都继承了Object类，那么就可能会重写equals()方法，如果不重写的话，使用的就是Object类的equals()方法，比较的就是两个对象是否是同一个对象，如果重写了equals()方法，那么就可以自己定义比较的方式，通常是比较两个对象的内容是否相同，如果相同的话就返回true，否则就返回false。另外object.equals(null)永远返回false，不同类型对象之间的比较也永远返回false。示例请参考原文。

2. hashCode() 的作用

hashCode()方法也定义在Object类中，这就意味着所有的类都有hashCode()方法，但是只有在创建类的散列表时，hashCode()方法才有用，其它情况下，例如创建类的单个对象或者类的对象数组等，hashCode()方法是没有用的，类的散列表是指类的HashMap、HashSet、HashTable容器。
hashCode()方法的返回值是一个int整数，也叫作哈希码，哈希码的作用是确定对象在哈希表中的索引，哈希表的本质是数组，当我们要获取数组中某个位置的元素时，这个位置索引就是通过键的hash码来获取的。那么HashSet是如何利用哈希码来保证容器中的元素不重复的呢？假设HashSet中已经有1000个元素，现在再添加一个元素，为了保证元素的唯一性，那么如果将要插入的元素与前面1000个元素进行逐一比较，那么显然效率是非常低下的，而散列表很好地解决了这个问题，它根据元素的散列码计算出元素在哈希表中位置，然后将该元素插入该位置即可，对于相同的元素，自然就只保存了一个。由此可知，如果两个元素相等，它们的散列码一定相等，而散列码相等的两个元素，它们却不一定相同，这也是HashMap底层为什么是数组+链表存储结构的原因。

3. hashCode() 和equals()的关系

3.1 不创建类对应的散列表

在这种情况下hashCode方法是没有任何用处的，equals()方法只是用来比较两个对象是否相等，我们通过例子来看一下对象相等和不相等时hashCode的值是否相等。

package com.interview;

public class HashCodeTest {

    public static void main(String[] args) {
        Person person1 = new Person(25, "jack");
        Person person2 = new Person(25, "jack");
        Person person3 = new Person(26, "mike");

        System.out.printf("person1.equals(person2)=%s   person1.hashCode()=%d  person2.hashCode()=%d\n",
                person1.equals(person2), person1.hashCode(), person2.hashCode());
        System.out.printf("person1.equals(person3)=%s   person1.hashCode()=%d  person3.hashCode()=%d",
                person1.equals(person3), person1.hashCode(), person3.hashCode());
    }

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

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


        @Override
        public boolean equals(Object obj) {

            //判断对象是否为null
            if (obj == null) {
                return false;
            }

            //判断是否是同一个对象
            if (this == obj) {
                return true;
            }

            //判断类型是否相同，是否加载的同一个class对象或者文件
            if (this.getClass() != obj.getClass()) {
                return false;
            }

            Person person = (Person) obj;

            return this.name.equals(person.name) && this.age == person.age;
        }
    }
}

运行结果：
person1.equals(person2)=true   person1.hashCode()=1878246837  person2.hashCode()=929338653
person1.equals(person3)=false   person1.hashCode()=1878246837  person3.hashCode()=1072591677

从运行结果来看，即使两个对象相等，它们的hashCode值也不一定相等。

3.2 创建类对应的散列表

创建类对应的散列表就是说我们会在HashTable、HashMap、HashSet等这些本质是散列表的数据结构中用到该类，在这种情况下hashCode()和equal()是有关系的：
(1).如果两个对象相等，那么hashCode()值一定相等，这里所说的相等是指通过equals()比较两个对象时返回true。
(2).如果两个对象的hashCode()相等，即两个对象的哈希值相等，并不一定能得出键值对相等，也就是说如果两个不同的键值对哈希值相等，这就是哈希冲突。在这种情况下，除了要重写equals()方法，还要重写hashCode()方法，如果不重写hashCode()方法，那么会出现什么情况呢？

package com.interview;

import java.util.HashSet;

public class HashCodeTest {

    public static void main(String[] args) {
        Person person1 = new Person(25, "jack");
        Person person2 = new Person(25, "jack");
        Person person3 = new Person(26, "mike");

        System.out.printf("person1.equals(person2)=%s   person1.hashCode()=%d  person2.hashCode()=%d\n",
                person1.equals(person2), person1.hashCode(), person2.hashCode());
        System.out.printf("person1.equals(person3)=%s   person1.hashCode()=%d  person3.hashCode()=%d\n",
                person1.equals(person3), person1.hashCode(), person3.hashCode());

        HashSet<Person> people = new HashSet<>();
        people.add(person1);
        people.add(person2);
        people.add(person3);
        System.out.println(people);
    }

    static class Person {

        private int age;
        private String name;

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


        @Override
        public boolean equals(Object obj) {

            //判断对象是否为null
            if (obj == null) {
                return false;
            }

            //判断是否是同一个对象
            if (this == obj) {
                return true;
            }

            //判断类型是否相同，是否加载的同一个class对象或者文件
            if (this.getClass() != obj.getClass()) {
                return false;
            }

            Person person = (Person) obj;

            return this.name.equals(person.name) && this.age == person.age;
        }

        @Override
        public String toString() {
            return name + ":" + age + " ";
        }
    }
}
运行结果：
person1.equals(person2)=true   person1.hashCode()=1878246837  person2.hashCode()=929338653
person1.equals(person3)=false   person1.hashCode()=1878246837  person3.hashCode()=1072591677
[mike:26 , jack:25 , jack:25 ]

从运行结果来看，HashSet中出现了两个重复的元素，这是因为我们没有重写hashCode()方法，person1和person2两个对象的hashCode值不相等，所以HashSet在添加这两个对象的时候，认为是两个不同的对象，这与我们的初衷不一致。
下面我们同时重写hashCode()和equals()方法：

package com.interview;

import java.util.HashSet;

public class HashCodeTest {

    public static void main(String[] args) {
        Person person1 = new Person(25, "jack");
        Person person2 = new Person(25, "jack");
        Person person3 = new Person(26, "mike");
        Person person4 = new Person(25, "JACK");

        System.out.printf("person1.equals(person2)=%s   person1.hashCode()=%d  person2.hashCode()=%d\n",
                person1.equals(person2), person1.hashCode(), person2.hashCode());
        System.out.printf("person1.equals(person3)=%s   person1.hashCode()=%d  person3.hashCode()=%d\n",
                person1.equals(person3), person1.hashCode(), person3.hashCode());
        System.out.printf("person1.equals(person4)=%s   person1.hashCode()=%d  person4.hashCode()=%d\n",
                person1.equals(person4), person1.hashCode(), person4.hashCode());

        HashSet<Person> people = new HashSet<>();
        people.add(person1);
        people.add(person2);
        people.add(person3);
        System.out.println(people);
    }

    static class Person {

        private int age;
        private String name;

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


        @Override
        public boolean equals(Object obj) {

            //判断对象是否为null
            if (obj == null) {
                return false;
            }

            //判断是否是同一个对象
            if (this == obj) {
                return true;
            }

            //判断类型是否相同，是否加载的同一个class对象或者文件
            if (this.getClass() != obj.getClass()) {
                return false;
            }

            Person person = (Person) obj;

            return this.name.equals(person.name) && this.age == person.age;
        }

        @Override
        public int hashCode() {
            return name.toUpperCase().hashCode()^age;
        }

        @Override
        public String toString() {
            return name + ":" + age + " ";
        }
    }
}

运行结果：
person1.equals(person2)=true   person1.hashCode()=2269126  person2.hashCode()=2269126
person1.equals(person3)=false   person1.hashCode()=2269126  person3.hashCode()=2366444
person1.equals(person4)=false   person1.hashCode()=2269126  person4.hashCode()=2269126
[jack:25 , mike:26 ]

通过运行结果可以看出，HashSet中没有了重复的元素，比较person1和person2，它们的hashCode相等，通过equals()比较返回true，所以它们被视为相等。而person1和person4，它们虽然hashCode相等，但是通过equals比较它们返回false，所以person1和person4被视为不相等。