Object.equals()、==和Object.hashCode()的差别和总结

1. Object.equals()和==

Java中所有的类都继承了Object这个类，所以所有的类的都拥有equals这个方法。

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

你会发现这个方法中直接就有用上 == 这个符号来进行比较，也就是说其实两者是没有差别的。

• 对于基本数据类型而言， 他没有equals这个方法， == 直接比较两者的值是否相等。
• 而对于引用数据类型而言，如果没有重写过equals方法的话，就会比较两者的引用是否相同，也就是直接比较两者在堆内存中是否是同一对象。

为什么要有equals()方法

个人认为主要是为了让我们在编程的时候可以重写这个方法，因为有时候对于我们而言，两个对象只要他的内部参数相同，那它就可以看成是相等。

而且事实上，Java内部中，String，Date和Integer之类的类中对equals()方法都进行了重写，重写后qeuals()方法会比较注重于对比其内部的参数是否相同。

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1.equals(str2));  //很明显不是同一个对象，但是是true
System.out.println(str1 == str2);   //false

为什么说equals()和==不同

别人的博客中经常说到，equals()和==是不同的，前者主要是比较两个类中内部的数据是否相等，后者比较两者在内存中是否是同一个对象。

这个说法本身没有问题，但是一定要有一个前提就是：equals()这个方法本身被重写过。

在别人的博客中，别人直接告诉我两者是不同的，但是为什么？明明在Object类中就是调用==这个符号。

但是实际上在我们常用的那些Java类中，equals()这个方法都被重写过了，被重写过后的方法主要上都是比较内部的参数是否相等。

所以结论是：因为Java中大部分类（如String，Date等）都已经重写过equals()方法，所以equals()和==是不同的。

如果没有这个前提，equals和==就是本质上区别就是一个是方法，一个是运算符。

2. Object.hashCode()

Java中所有的类都继承了Object这个类，所以所有的类的也拥有hashCode()这个方法。

哈希码

想知道hashCode这个方法到底有什么用，就要先对哈希码有个基本的了解。

哈希码会返回一个对象经过内存地址处理后的结构，由于每个对象的内存地址都不一样，所以每个对象的哈希码都不一样。

• 简单来说，hashCode就会将这个对象在内存中的地址，转换成一个整数，由于每个对象的地址都不一样，所以每个对象的哈希码都不一样。
• 这里说的内存地址是值JVM所虚拟出来的内存地址，并不是物理意义上的内存地址。
• 根据上一条，哈希值和地址值是不一样的，哈希值是通过哈希算法散列得到的，而地址值则是根据物理的内存地址决定的。前者是逻辑上的不同，后者则是物理上的不同。

哈希码相同但是是不同对象

我参考了很多其他博客，在其他博客中，它们都提到了这个说法，其中一部分说Integer和String有这样的特性。
最终，我自我总结得到这样一个结论。

这句话没有问题，但是要加上一个前提：hashCode()这个方法被重写过。

是这样的，在Java中有个不成文的规定，每当重写equals方法的同时，也要重写hashCode这个方法，来使得hashCode和equals都能够通过判断不同对象的内部参数来得出两个对象是否相等。

至于为什么说不成文呢，因为实际上你不去重写，也不会报错和发生问题，但是为了正常的设计程序在重写equals的同时也会重写hashCode。
为什么要重写hashcode方法和equals方法 - 朝阳的自留地 - 博客园
https://www.cnblogs.com/vincentme/p/10642456.html

所以结论是：因为Java中大部分类（如String，Integer等）都已经重写过hashCode()方法，所以会出现哈希码相同但是是不同对象的情况，如果没有重写过，是不会出现这种情况的。

而下面我举String类和Integer类为例，但是要注意，这两个类的equals和hashCode方法是被重写过的。

String的hashCode

String的equals方法正如我们想的那样，两个字符串的字符一个个比对，hashCode会以31为权，计算每个字符的对应ASCII的数字。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    
    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;
    }
    
	public int hashCode() {
	    int h = hash;
	    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;
	}
}

String str1 = "aaa";
String str2 = "bbb";
String str3 = new String("aaa");
String str4 = new String(str2);
System.out.println(str1.hashCode()); // 96321
System.out.println(str2.hashCode()); // 97314
System.out.println(str3.hashCode()); // 96321   和str1相同
System.out.println(str4.hashCode()); // 97314

System.out.println(str3.equals(str4)); // false
System.out.println(str3.equals(str1)); // true
System.out.println(str3 == str1); // false 证明不是同一对象

有关String的hashCode还会有不同内容的字符串，hashCode相同的情况。

String str5 = "gdejicbegh";
String str6 = "hgebcijedg";
System.out.println(str5.hashCode());  //-801038016
System.out.println(str6.hashCode());  //-801038016

Integer的hashCode

在Integer类中，hashCode的值就是数字的大小，equals也是通过比较数字是否相等来判断t/f

public final class Integer extends Number implements Comparable<Integer> {
	//只列出相关性强的方法
    private final int value;

    public Integer(int value) {
        this.value = value;
    }

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

    @Override
    public int hashCode() {
        return Integer.hashCode(value);
    }
    
    public static int hashCode(int value) {
        return value;
    }

}

Integer integer1 = 10;
Integer integer2 = new Integer(10);
System.out.println(integer1.hashCode());  // 10
System.out.println(integer1.hashCode());  // 10
System.out.println(integer1 == integer2); //false， 很明显不是同一对象
System.out.println(integer1.equals(integer2)); // true

3. equals和hashCode的关系

首先要弄清两个对象相等和同一对象的区别。

重写equals的方法主要是为了比对两个对象是否相等，如果不重写则是判断是否是同一对象。

而我们在重写equals方法后会同时重写hashCode方法，让每一个对象生成一个独特的int值，但是由于重写是由我们手动编写算法，所以不一定能保证真正意义上的每个对象一个int值（事实上，Java本身的String类也不能如此保证）。最终有如下一个结论。

1. hashCode相同，并不能保证equals返回为true。
2. equals返回为true，则hashCode一定相同。

参考材料

Java Object类的equals()方法 - 考拉熊_12 - 博客园
https://www.cnblogs.com/naihuangbao/p/9445027.html
JAVA-初步认识-第十一章-object类-Hashcode方法 - 前锋营 - 博客园
https://www.cnblogs.com/wsw-bk/p/8026231.html
Java哈希值HashCode理解 - weixin_42304845的博客 - CSDN博客
https://blog.csdn.net/weixin_42304845/article/details/82216390
为什么要重写hashcode方法和equals方法 - 朝阳的自留地 - 博客园
https://www.cnblogs.com/vincentme/p/10642456.html
hashCode之一–两个对象值相同,有相同的hash code - duanxz - 博客园
https://www.cnblogs.com/duanxz/p/3724275.html