java -为什么重写equals()，还需要重写hashCode()?

た入场券 2023-06-05 12:38 46阅读 0赞

### 1.先post这两个方法的基本定义： ###

equals()的定义：

# [浅谈Java中的equals和==(转)][Java_equals] #

hashCode()的定义：

# [java中hashCode()方法的作用][java_hashCode] #

# [Java中hashCode的实现][Java_hashCode] #

这两个方法全部都是object类定义的方法，只要继承了object类的类，默认继承这两个方法。看源码，

**（1）package java.lang.Object.equals()**

![1146339-20190903141815671-1468652189.png][]

可见，默认这个方法是比较这两个引用对象的实际存储的内存地址是否相同。当然，即便是同一个类创建的两个对象，他们的内存地址也是不同的，所以，默认的equals()只有内存地址相同的对象（其实就是同一个引用对象的自己与自己的比较，这还有这样他们的地址才会相同），才会返回true。

当然，其他的很多类继承Object后，会对equals（）进行重写，它会对两个对象的类型和对象内的内容进行比较，这个equals()对字符串相同的对象会得到true。可以看下String类中重写的equals()方法。

如下代码：

String s1="uiop0";
    String s2="uiop0";
    System.out.println(s1.equals(s2));

可以看下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;
        }

（2）**package java.lang.Object.hashCode()**

Object的hashCode（）默认也是对两个对象存储地址值的哈希，所以，两个内容相同的对象的哈希值也会是不同的，所以重写hashCode()也是根据我们需求来修改hashCode()的功能，比如，String类的hashCode()的功能，对内容相同的字符串变量，会返回相同的哈希值。如果是调用Object的hashCode（）方法，因为两个String变量是两个引用对象，返回的哈希值肯定不相等的。

**看看String中的hashCode（）源码：**

public int hashCode() {
            int h = hash;//默认hash=0
            if (h == 0 && value.length > 0) {
                char val[] = value;
    
                for (int i = 0; i < value.length; i++) {
                    h = 31 * h + val[i];
                }
                hash = h;
            }
            return h;
        }

可以看见，它是对两个字符串按照下面的规则，计算新的哈希值，这样算出的来两个相同字符串相变量哈希值是相等的。

h = 31 * h + val[i];

###  **2.解释一下，为什么重写equals()，还需要重写hashCode()的原因** ###

主要原因是定义的新的类在使用hashMap()是实际到，key值的计算问题。当我们用自定义的类的作为key时，怎么判断这相同的类对象的唯一性，这里涉及到hashMap()的判断机制，先比较hashCode()，当哈希值相同时，再比较equals()，这两个是配套的。

看先下面的详细解释：

![1146339-20190903150617202-1906213654.png][]

转载于:https://www.cnblogs.com/zz22--/p/11453134.html

[Java_equals]: https://www.cnblogs.com/mrhgw/p/9199512.html
[java_hashCode]: https://www.cnblogs.com/hujingwei/p/5322821.html
[Java_hashCode]: https://www.jianshu.com/p/6be2e37aca6f
[1146339-20190903141815671-1468652189.png]: /images/20230601/aeced17337c848d78794dd043b470ac4.png
[1146339-20190903150617202-1906213654.png]: /images/20230601/797ea1630c5643c0a813209e2b674f18.png