hashCode()和equals()，equals重写为什么一定会重写hashCode()方法？

柔光的暖阳◎ 2024-03-16 12:55 52阅读 0赞

![183630813d074c539beba2591aeb1193.png][]

## 一、Java 的 hashCode 方法 ##

**hashCode是Java中Object类的一个方法，用来返回对象的哈希码**。哈希码是一个整数值，它可以用来快速比较两个对象是否相等。

在Java中，哈希码的计算方式是由对象的内存地址转换而来的。也就是说，如果两个对象的内存地址不同，那么它们的哈希码一定不同；反之，如果两个对象的内存地址相同，那么它们的哈希码可能相同，但也可能不同。

因为每个对象都有自己的哈希码，所以可以将哈希码作为该对象的唯一标识符，并将其用于各种数据结构和算法中，如散列表、集合、映射等。

在Java中，我们可以通过重写hashCode()方法来改变对象的哈希码计算规则。通常情况下，我们需要同时重写equals()方法和hashCode()方法，以保证对象的相等性判断正确无误。

以下是一个示例代码：

public class Person {
        private String name;
        private int age;
     
        // 省略了构造函数和getter/setter方法
     
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
     
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    }

在上面的代码中，我们重写了hashCode()方法，采用了经典的哈希码计算方式。其中，使用31这个质数是为了让乘法运算更快，并确保结果不会相同；而通过将属性值进行异或运算，则可以避免产生完全相同的哈希码。

同时，我们还重写了equals()方法，根据对象的属性值来判断两个对象是否相等。

需要注意的是，如果一个类重写了equals()方法，那么也必须同时重写hashCode()方法，否则可能导致该类的实例无法正确存储到散列表、集合和映射等数据结构中。

hashCode()方法是Object类中的一个方法，用来返回对象的哈希码。在实现这个方法时需要遵循以下规则：

1.  在应用程序执行期间，如果在两次调用 equals 方法时对象的比较结果不变，则要求 hashCode 方法返回相同的整数。
2.  如果根据 equals(Object) 方法，两个对象是相等的，则对这两个对象调用 hashCode 方法必须生成相同的整数结果。
3.  如果根据 equals(Object) 方法，两个对象不相等，则对这两个对象调用 hashCode 方法不一定要生成不同的整数结果。

以下是一个简单的Java hashCode()方法的样例：

public class Person {
        private int id;
        private String name;
     
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + id;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
    }

在上述代码中，我们重写了hashCode()方法，并使用id和name字段来计算哈希码。其中，prime是一个质数，可以提高哈希码的分布均匀性，result是初始值为1的变量，用于存储最终计算出来的哈希码。

在计算哈希码时，我们首先将result乘以prime，然后加上id的哈希码，再乘以prime，最后加上name的哈希码（如果name为null，则加上0）。最终得到的result就是该对象的哈希码。

![374c69f1389742d6ad72fb76c65911dd.png][]

## 二、Java 的 equals 方法 ##

Java中的equals()方法是Object类中定义的一个公共方法，其作用是比较两个对象的内容是否相等。

在默认情况下，Object类的equals()方法实现是比较两个对象的地址是否相同（即比较引用是否指向同一内存地址）。

但通常情况下，我们希望比较的是对象的内容是否相等。为此，我们需要根据具体情况重写equals()方法，让它比较对象的属性值是否相等。

重写equals()方法时需要遵循以下原则：

1.  对称性：如果x.equals(y)返回true，则y.equals(x)也应该返回true。
2.  反射性：x.equals(x)始终返回true。
3.  传递性：如果x.equals(y)返回true，且y.equals(z)返回true，则x.equals(z)也应该返回true。
4.  一致性：多次调用x.equals(y)的结果始终相同，只要x和y的属性值没有发生变化。
5.  非空性：x.equals(null)应该始终返回false。

下面是一个简单的示例，演示如何重写equals()方法：

public class Person {
        private String name;
        private int age;
    
        // 省略构造器、getter和setter方法
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true; // 如果是同一个对象，直接返回true
            if (obj == null || getClass() != obj.getClass()) return false; // 如果传入的对象为null或不是同一个类的实例，返回false
            Person person = (Person) obj; // 强制类型转换
            return age == person.age && Objects.equals(name, person.name); // 比较属性值是否相等
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age); // 返回哈希码
        }
    }

上面的代码中，我们重写了equals()方法，比较的是Person对象的name和age字段是否相等。此外，还重写了hashCode()方法，以保证在使用散列表（如HashMap）时能够正确地识别每个对象。

以下是一个简单的Java的equals方法样例：

public class Person {
        private int id;
        private String name;
        
        // 构造函数、getter/setter方法省略
        
        @Override
        public boolean equals(Object obj) {
            if (this == obj)  // 如果是同一对象直接返回true
                return true;
            if (obj == null || getClass() != obj.getClass())  // 如果obj为null或者两个对象类型不同，返回false
                return false;
    
            Person person = (Person) obj;  // 向下转型
    
            // 对比属性值是否相等
            if (id != person.id)
                return false;
            return name.equals(person.name);
        }
    }

在上面的代码中，我们定义了一个Person类，并重写了它的equals方法。

在equals方法中，我们首先使用“==”运算符判断两个对象是否引用同一个对象。如果是，则直接返回true；否则，我们再检查传入的参数是否为null以及两个对象的类类型是否相同。如果满足以上条件，则将传入的对象向下转型为Person类型，并对比该对象的各个属性值是否相等（在本例中只有id和name两个属性）。如果id和name都相等，则返回true，否则返回false。

> 注意：equals方法需要遵循反射性、对称性、传递性和一致性原则。详情可以参考Java官方文档中的说明。

![a22625eaf38542cb87a424437572cf35.png][]

## 三、equals重写为什么一定会重写hashCode()方法 ##

在Java中，当我们重写一个类的equals()方法时，必须同时重写hashCode()方法，这是因为两者之间具有严格的语义关系。

**hashCode()方法是用于计算对象哈希码的方法，哈希码可以理解为对象的数字指纹，用于快速比较两个对象是否相等**。而一旦我们重写了equals()方法，就会改变对象的相等性判断方式，从原来的基于引用地址的相等性判断变成了基于对象内容的相等性判断。

如果我们只重写equals()方法而不重写hashCode()方法，则可能会导致以下问题：

1.  在使用哈希表（例如HashMap、HashSet等）等需要进行哈希运算的数据结构中，如果两个对象根据equals()方法判断相等，但它们的哈希码不同，那么它们将被认为是两个不同的对象，导致无法正确查找或删除。
2.  如果我们将某个对象存储在哈希表中，并且该对象的哈希码发生变化，那么哈希表可能会无法正确地查找到该对象。

因此，为了避免以上问题，当我们重写equals()方法时，也必须要重写hashCode()方法，以保持两者之间的语义一致性。通常，我们可以在对象的属性上进行一些基本的哈希计算，然后将结果合并起来作为对象的哈希码。

![e56705da5a9646398568d5ee8a1812fd.png][]

[183630813d074c539beba2591aeb1193.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/79cf640526284eae82b6a6141abb88b6.png
[374c69f1389742d6ad72fb76c65911dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2972f53dfbe4496183fce1890298a9e2.png
[a22625eaf38542cb87a424437572cf35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/72040c8e45a34d5daed8ad7aff976b47.png
[e56705da5a9646398568d5ee8a1812fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3976a3d91482408fa14c4f90ce2e1309.png