hashCode、identityHashCode、equals和==的原理详解

文章目录

1. hashCode概念
2. hash冲突
3. hashCode设计
4. identityHashCode
5. == 和 equals

1. hashCode概念

hashCode是jdk根据对象的地址算出来的一个int数字，即对象的哈希码值，代表了该对象在内存中的存储位置。

我们都知道hashCode()方法是顶级类Object类的提供的一个方法，所有的类都可以进行对hashCode方法重写。

我们也知道在比较一个对象中的内容是否相同时往往会重写equals方法，值得注意的是，重写equals方法的同时必须也要重写hashCode方法，多次调用一个对象的hashCode方法必须返回同一个数字，这也是必须遵守的规范，不然会造必须存在的危害。

2. hash冲突

当两个对象equals相同，hashCode规定也必须相同，但反过来就不一定。两个对象对应一个hashCode，但equal却不一定相等。这就是传说中的hash冲突的场景。

HashMap是以hashCode取模数组形式存放值的，那两个对象hashCode一样会不会造成前一个对象的值覆盖呢？答案是不会，因为它采用了另外一种链表数据结构来解决hash冲突的情况，即使两个对象的hashCode一样，它们会放到当前数组索引位置的链表中。所以，即使有相同的hashCode，equal却不一定相等。

3. hashCode设计

HashSet通过HashMap来实现的，用来存储不重复数据的，怎么判断里面的对象是否重复呢？判断对象是否重复即是判断对象里面的属性是否都一样，这时必须是重写了equals方法去比较对象的里面所有的值，而不是比较引用地址，比较引用地址它们永远都不相等，除非是同一个对象。通过equals比较的过程性能是非常不佳的，所以有了hashCode这个设计，可以先通过比较对象的hashCode是否一样确定是不是同一个对象，如果hashCode不一样这时肯定就不是同一个对象，反之如果hashCode一样而且equals或者也一样这肯定就是同一个对象。所以先比较对象的hashCode再比较equals或者，这样效率会明显提升。

假如我们重写了equals而不重写hashCode方法，多个对象属性值一样的它们的hashCode肯定是不一样的，这时作为key在put到map中的时候，就会有多个这样的key，而达不到对象作为key的场景，同样也达不到HashSet去重的效果。因为HashSet通过HashMap来实现的，HashMap的Key是通过hashcode实现的。

4. identityHashCode

identityHashCode是System里面提供的本地方法

/**
 * Returns the same hash code for the given object as
 * would be returned by the default method hashCode(),
 * whether or not the given object's class overrides
 * hashCode().
 * The hash code for the null reference is zero.
 *
 * @param x object for which the hashCode is to be calculated
 * @return  the hashCode
 * @since   JDK1.1
 */
public static native int identityHashCode(Object x);

identityHashCode和hashCode的区别是，identityHashCode会返回对象的hashCode，而不管对象是否重写了hashCode方法。

看一个例子：

public static void main(String[] args) {
    String str1 = new String("abc");
    String str2 = new String("abc");
    System.out.println("str1 hashCode: " + str1.hashCode());
    System.out.println("str2 hashCode: " + str2.hashCode());
    System.out.println("str1 identityHashCode: " + System.identityHashCode(str1));
    System.out.println("str2 identityHashCode: " + System.identityHashCode(str2));

    User user = new User("test", 1);
    System.out.println("user hashCode: " + user.hashCode());
    System.out.println("user identityHashCode: " + System.identityHashCode(user));
}

输出结果：

str1 hashCode: 96354
str2 hashCode: 96354
str1 identityHashCode: 1173230247
str2 identityHashCode: 856419764
user hashCode: 621009875
user identityHashCode: 621009875

结果分析：

1、str1和str2的hashCode是相同的，是因为String类重写了hashCode方法，它根据String的值来确定hashCode的值，所以只要值一样，hashCode就会一样。

2、str1和str2的identityHashCode不一样，虽然String重写了hashCode方法，identityHashCode永远返回根据对象物理内存地址产生的hash值，所以每个String对象的物理地址不一样，identityHashCode也会不一样。

3、User对象没重写hashCode方法，所以hashCode和identityHashCode返回的值一样。

经过我的测试，ArrayList也重写了Hashcode方法，其HashCode根据ArrayList中的内容计算得到，只要两个ArrayList中的内容一样，其HashCode就一致

public static void main(String[] args) {
    ArrayList<String> a=new ArrayList<String>();
    ArrayList<String> b=new ArrayList<String>();
    a.add("hello");
    a.add("world");
    b.add("hello");
    b.add("world");
    System.out.println(a.hashCode());//-1107615551
    System.out.println(b.hashCode());//-1107615551
}

输出：

1 2	-1107615551 -1107615551

结论

hashCode方法可以被重写并返回重写后的值，identityHashCode会返回对象的hash值而不管对象是否重写了hashCode方法。

5. == 和 equals

可以先参考一下Java简单数据类型和封装类中的equals和"=="

java中的数据类型，可分为两种：

基本数据类型，也称原始数据类型。byte,shrot,char,int,long,float,double,boolean（存储在内存中的堆栈（以后简称栈））
- 他们之间的比较，应用双等号（==)，比较的是他们的值。
引用类型（类，复合数据类型）（在栈中仅仅是存储引用类型的变量的地址，而其本身则存储在堆中）
- 当他们用（==）进行比较的，比较的是他们在内存中的存放地址，（即栈中的内容是否相等）所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后的结果为false。重写后的equals操作表示的两个变量是否是对同一个对象的引用（即堆中的内容是否相等）

这里问题来了，对于引用类型，==底层比较的是hashcode吗？

就拿上面的例子来说

public static void main(String[] args) {
    ArrayList<String> a=new ArrayList<String>();
    ArrayList<String> b=new ArrayList<String>();
    a.add("hello");
    a.add("world");
    b.add("hello");
    b.add("world");
    System.out.println(a.hashCode());//-1107615551
    System.out.println(b.hashCode());//-1107615551
    System.out.println(a==b);
}

输出结果：

1
2
3

-1107615551
-1107615551
false

可以看到，两个hashcode相等的对象，==结果为false，所以，引用类型的==等于等层实现并不是hashcode。

那是什么呢？肯定是identityHashCode，无论对象是否重写了hashCode方法，它返回的都是对象的地址

再来看equals，equals是Object中的方法，与==不同，equals()是一个方法，我们可以推测知道，它其中的实现所使用的肯定是==运算符。再进一步的思考，equals()本意不正是==运算符进行对象比较时候的作用吗。那么，既然是两者有同样的作用，为什么还要弄出一个equals()方法来呢？因为==运算符不允许我们进行覆盖，为了实现某些功能（比如判断两个对象中的内容是否相等），我们必须对equals方法进行重写才能实现，所以java引入了equals方法。如果对象没有实现equals方法，equals的效果等同于==。

来看一个例子，验证一下：

class UserA{
	String name;
	public UserA(String name){
		this.name=name;
	}
}

class UserB{
	String name;
	public UserB(String name){
		this.name=name;
	}
	@Override
	public boolean equals(Object obj){
		UserB userb=(UserB)obj;
		if(this.name.equals(userb.name))
			return true;
		else return false;
	}
}

public class Test6 {

	public static void main(String[] args) {
		UserA a1=new UserA("layne");
		UserA a2=new UserA("layne");
		
		UserB b1=new UserB("wxler");
		UserB b2=new UserB("wxler");
		
		System.out.println(a1==a2);//false
		System.out.println(a1.equals(a2));//false
		
		System.out.println(b1==b2);//false
		System.out.println(b1.equals(b2));//true
	}

}

可以看到，当一个类没有重写equals方法时，equals和==其实是一样的，比较的都是内存地址是否一致。在重写了equals方法之后，equals和==就不一样了，此时，equals比较的是两个对象的内容是否相等，==比较的是两个对象的内存地址是否相等。

上面也提到过，如果一个类重写了equals方法，必然也会重写hashCode方法，否则可能造成不必要的错误。另外，当一个类重写hashCode方法之后，基本上都会重写equals方法，这两者只要重写一个，另一个必将会重写，这样才能保持一致性。

public static void main(String[] args) {
	ArrayList<String> a=new ArrayList<String>();
	ArrayList<String> b=new ArrayList<String>();
	a.add("hello");
	a.add("world");
	b.add("hello");
	b.add("world");

	System.out.println(a==b);//false
	System.out.println(a.equals(b));//true
}

上面，ArrayList即重写了hashcode方法，也重写了equals方法。