Why HashCode?
hashCode()是Java中Object类的一个方法
public native int hashCode();
根据这个方法声明,该方法返回一个int类型哈希值,并且作为native本地方法,在Object类中没有具体实现。
hashCode方法作用
对于集合而言,最重要的就是基于散列的快速查找,快速增删的能力,而hashCode方法方便了hashSet, hashMap, hashTable等等的基于哈希查找的集合正常运行。
一般快速查找对应的下标,要么是像数组一样能够直接快速按照下标一个个取出,否则就得调用equals()方法一个个遍历后比较,但是hashCode牛🐂就牛🐂在它将与此对象相关的字段,映射成一个唯一的数值 (只要你与别人有一点点不一样,那么你俩的hashCode就完全不一样)
实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值。
如果table中没有该hashcode值,它就可以直接存进去,不用再进行任何比较了;
如果table存在该hashcode值, 就调用它的equals方法与新元素进行比较,相同的话就不存了;不相同就散列其它的地址。
所以这里存在一个冲突解决的问题,这样一来实际调用equals方法的次数就大大降低了
hashCode方法误区
误区1:
hashCode就是对象存储地址?
有些朋友误以为默认情况下,hashCode返回的就是对象的存储地址,事实上这种看法是不全面的。
确实有些JVM在实现时是直接返回对象的存储地址,但是大多时候并不是这样,只能说可能存储地址有一定关联。下面是HotSpot JVM中生成hash散列值的实现
static inline intptr_t get_next_hash(Thread * Self, oop obj) {
intptr_t value = 0 ;
if (hashCode == 0) {
// This form uses an unguarded global Park-Miller RNG,
// so it's possible for two threads to race and generate the same RNG.
// On MP system we'll have lots of RW access to a global, so the
// mechanism induces lots of coherency traffic.
value = os::random() ;
}else
if (hashCode == 1) {
// This variation has the property of being stable (idempotent)
// between STW operations. This can be useful in some of the 1-0
// synchronization schemes.
intptr_t addrBits =intptr_t(obj) >> 3 ;
value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
}else
if (hashCode == 2) {
value = 1 ; // for sensitivity testing
}else
if (hashCode == 3) {
value = ++GVars.hcSequence ;
}else
if (hashCode == 4) {
value =intptr_t(obj) ;
}else {
// Marsaglia's xor-shift scheme with thread-specific state
// This is probably the best overall implementation -- we'll
// likely make this the default in future releases.
unsigned t = Self->_hashStateX ;
t ^= (t << 11) ;
Self->_hashStateX = Self->_hashStateY ;
Self->_hashStateY = Self->_hashStateZ ;
Self->_hashStateZ = Self->_hashStateW ;
unsigned v = Self->_hashStateW ;
v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
Self->_hashStateW = v ;
value = v ;
}
value &= markOopDesc::hash_mask;
if (value == 0) value = 0xBAD ;
assert (value != markOopDesc::no_hash,"invariant") ;
TEVENT (hashCode: GENERATE) ;
return value;
}
误区2:
hashCode值能直接用于判断两个对象是否相同
有人会说,可以直接根据hashcode值判断两个对象是否相等吗?
肯定是不可以的,因为不同的对象可能会生成相同的hashcode值。虽然不能根据hashcode值判断两个对象是否相等,但是可以直接根据hashcode值判断两个对象不等,如果两个对象的hashcode值不等,则必定是两个不同的对象。
如果要判断两个对象是否真正相等,必须通过equals方法。
总结:
如果有以下两个对象 a, b
- 如果
a.equals(b)
返回true
,则a.hashCode() == b.hashCode()
也一定为true
- 如果
a.equals(b)
返回false
,则a.hashCode() == b.hashCode()
不一定为false
,也可以是true
- 如果
a.hashCode() == b.hashCode()
,那么a.equals(b)
结果也不确定 - 如果
a.hashCode() != b.hashCode()
,那么a.equals(b)
结果一定是false
重写hashCode()
在有些情况下,程序设计者在设计一个类的时候为需要重写equals方法,比如String类。
但是千万要注意,在使用到集合类时,重写equals方法的同时,必须重写hashCode方法。
为什么这么说呢?看这个例子:
package com.java.test1;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
class People{
private String name;
private int age;
public People(String name,int age) {
this.name = name;
this.age = age;
}
public void setAge(int age){
this.age = age;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return this.name.equals(((People)obj).name) &&this.age== ((People)obj).age;
}
}
public class Main {
public static void main(String[] args) {
People p1 =new People("Jack",12);
System.out.println(p1.hashCode());
HashMap<People, Integer> hashMap =new HashMap<People, Integer>();
hashMap.put(p1,1);
System.out.println(hashMap.get(new People("Jack",12)));
}
}
上面的例子:只重写了equals方法,也就说如果两个People对象,如果它的姓名和年龄相等,则认为是同一个人。
1175962212
null
Process finished with exit code 0
原本我们期待最后一行打印的是:1,但实际上输出结果为“null”。原因就在于重写equals方法的同时忘记重写hashCode方法。
虽然通过重写equals方法使得逻辑上姓名和年龄相同的两个对象被判定为相等的对象(跟String类类似),但是要知道默认情况下,hashCode方法是将对象的存储地址进行映射。那么上述代码的输出结果为“null”就不足为奇了。
原因很简单,p1指向的对象和System.out.println(hashMap.get(new People(“Jack”, 12))); 这句中的new People(“Jack”, 12)生成的是两个对象,它们的存储地址肯定不同。
因此,如果想要上述代码输出:1,则只需要重写People类中的hashCode方法,让equals方法和hashCode方法始终在逻辑上保持一致性。
将默认的hashCode方法改写为如下
@Override
public int hashCode() {
// TODO Auto-generated method stub
return name.hashCode()*37 +age;
}
⚠️上面这段代码仍然有风险:如果name是一个容易改变的字段,最好不要依赖它生成hashCode,否则会因为name的修改导致存储进入hashMap中的数据丢失。
在《Java编程思想》一书中的P495页也有同第一条类似的一段话:
“设计hashCode()时最重要的因素就是:无论何时,对同一个对象调用hashCode()都应该产生同样的值。如果在将一个对象用put()添加进HashMap时产生一个hashCdoe值,而用get()取出时却产生了另一个hashCode值,那么就无法获取该对象了。所以如果你的hashCode方法依赖于对象中易变的数据,用户就要当心了,因为此数据发生变化时,hashCode()方法就会生成一个不同的散列码”。
具体是什么意思呢,下面还是沿用上面的People类举个例子:
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
People p1 =new People("Jack",12);
System.out.println(p1.hashCode());
HashMap<People, Integer> hashMap =new HashMap<People, Integer>();
hashMap.put(p1,1);
p1.setAge(13);
System.out.println(hashMap.get(p1));
}
}
class People{
private String name;
private int age;
public People(String name,int age) {
this.name = name;
this.age = age;
}
public void setAge(int age){
this.age = age;
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return name.hashCode()*37+age;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return this.name.equals(((People)obj).name) &&this.age == ((People)obj).age;
}
}
上面的代码最终输出是:
null
Process finished with exit code 0
由于People类中hashCode的计算依赖于 name 和 age,但是 age在程序中由于setAge()发生了改变,从而同一个对象p1产生了不一样的hashCode,也就无法找到对应在HashMap中存储的原数据了。