在说hash(key)方法之前,下面来简单模拟下HashMap中的put()方法,来查看哈希冲突:
最简单的情况,在下面代码中,用一个Object[]数组充当链表数组,判断str实例对象的hashCode值并得到在数组中存放的下标,然后放入数组。
/*
说明:
1.有一些对象需要放入到一个数组中(为什么要把它们放入数组,可以探究为什么会产生哈希算法?)
2.问题来了,怎么确定该对象应该放到数组中哪个位置,不可能每个程序员都制定一套规则,让这个对象放到某个位置,没有统一的标准
3.哈希算法就可以将一个对象映射成一串二进制,这串二进制又可以转换成十进制整数
4.也就是某对象和它通过哈希算法产生的十进制整数是映射关系,对应的
5.可以通过十进制来研究该把放入到数组中哪个位置
6.发现用十进制数对数组长度取模,可以将所有对象都限制在数组长度范围内
7.这就解决了把这对象放到数组中哪个位置的问题
*/
public class Demo {
public static void main(String[] args) {
String str=new String("abc");
System.out.println(str);
// 获取str的hashCode值
int hashCode = str.hashCode();
System.out.println(hashCode);
// 将获得的所有对象存放到一个长度为20的数组中
Object[] arr=new Object[20];
int index = hashCode%arr.length;
System.out.println(index);
// 然后将该对象放入数组中对应下标的位置
arr[index]=str;
System.out.println(Arrays.toString(arr));
}
}
当加入很多个对象时,可能某个对象的hashCode值对数组长度取模得到的下标,在数组中已经存在某个对象了,这就产生了冲突
/*
说明:
1.有一些对象需要放入到一个数组中(为什么要把它们放入数组,可以探究为什么会产生哈希算法?)
2.问题来了,怎么确定该对象应该放到数组中哪个位置,不可能每个程序员都制定一套规则,让这个对象放到某个位置,没有统一的标准
3.哈希算法就可以将一个对象映射成一串二进制,这串二进制又可以转换成十进制整数
4.也就是某对象和它通过哈希算法产生的十进制整数是映射关系,对应的
5.可以通过十进制来研究该把放入到数组中哪个位置
6.发现用十进制数对数组长度取模,可以将所有对象都限制在数组长度范围内
7.这就解决了把这对象放到数组中哪个位置的问题
8.但又要添加一个对象到数组中,也通过hashCode值确定了该放在数组中哪个位置
9.但是,在该位置已经存在一个对象了,而对于这种多个对象共用一个地址的情形,就称之为冲突
10.有了冲突,自然是需要解决冲突,解决冲突的其中一种就是链地址法,也称为拉链法
*/
public class Demo {
public static void main(String[] args) {
String str=new String("abc");
System.out.println(str);
// 获取str的hashCode值
int hashCode = str.hashCode();
System.out.println(hashCode);
// 将获得的所有对象存放到一个长度为20的数组中
Object[] arr=new Object[20];
int index = hashCode%arr.length;
System.out.println(index);
// 然后将该对象放入数组中对应下标的位置
arr[index]=str;
System.out.println(Arrays.toString(arr));
System.out.println("---------------------------------------------");
// 现在又要往数组中添加一个对象
String str2=new String("r");
System.out.println(str2);
int hashCode2 = str2.hashCode();
System.out.println(hashCode2);
int index2=hashCode2%20;
System.out.println(index2);
arr[index]=str2;// 发现"abc"和"r"在数组中存储的地址是一样的,这产生了冲突
System.out.println(Arrays.toString(arr));
}
}
事实上,我们并不希望后面的对象将已经存在的覆盖掉,就必须解决冲突,通过将元素存储在LinkedList中来模拟存储冲突元素的链表。
public class Demo2 {
public static void main(String[] args) {
String str=new String("abc");
System.out.println(str);
// 获取str的hashCode值
int hashCode = str.hashCode();
System.out.println(hashCode);
// 将获得的所有对象存放到一个长度为20的数组中
Object[] arr=new Object[20];
int index = hashCode%arr.length;
System.out.println(index);
// 然后将该对象放入数组中对应下标的位置
LinkedList linkedList=new LinkedList<>();
linkedList.add(str);
arr[index]=linkedList;
// arr[index]=str;
System.out.println(Arrays.toString(arr));
System.out.println("---------------------------------------------");
// 现在又要往数组中添加一个对象
String str2=new String("r");
System.out.println(str2);
int hashCode2 = str2.hashCode();
System.out.println(hashCode2);
int index2=hashCode2%20;
System.out.println(index2);
if(arr[index2]!=null){// 不为null的话表示已经存在元素了,采用链地址法,将地址相同的对象挂在后面
LinkedList list = (LinkedList)arr[index2];
list.add(str2);
}
// arr[index]=str2;// 发现"abc"和"r"在数组中存储的地址是一样的,这产生了冲突
System.out.println(Arrays.toString(arr));
}
}
下面是来模拟26个英文字母存放到哈希表中:
public class Demo3 {
public static void main(String[] args) {
// 26个英文字母的字符串
String va = "abcdefghijklmnopqrstuvwxyz";
// 将字符串转成字符数组
char[] vaArr = va.toCharArray();
// 创建一个链表数组,用来存储对象
Object[] obj = new Object[10];
// 循环遍历字符数组
for (Character c : vaArr) {
// 获取到该字符对象的hashCode值,是一个十进制的整数
int hashCode = c.hashCode();
// 将hashCode值对数组长度取模,得到该字符对象应该存放到数组的哪一个位置
int index = hashCode % obj.length;
// 判断得到的下标在数组中是否已经有元素,没有元素则为null
if (obj[index] == null) {
// 创建一个链表,存放冲突的元素
LinkedList
看到打印结果真的是冲突的元素非常多,将数组长度调整为20,情况有所好转
调为50,发现冲突的元素就少了很多,几乎没有冲突。
上面这些只是对哈希表有个更加深刻的认识,下面来谈谈hash(key)方法。
通过上面的代码就知道了哈希表的原理很简单,调用Object对象的hashCode()方法,该方法会返回一个整数,然后用这个数对HashMap或者HashTable的容量进行取模就行了。
但HashMap的实现却不是这样简单,更多的需要为效率考虑。
所以hash(key)方法就是返回哈希值,查看源码如下:
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
那么思考下,为什么不直接如下面这样呢?
int hash (Object k) {
return k.hashCode();
}
多么简洁易读,而且我们上面的模拟就是这样干的,那为什么不这样呢?
看下面的代码:
public class Demo2 {
public static void main(String[] args) {
String str=new String("abc");
System.out.println(str);
// 获取str的hashCode值
int hashCode = str.hashCode();
System.out.println(hashCode);
// 将获得的所有对象存放到一个长度为16的数组中,满足使用位运算的情况,length是2的n次方
Object[] arr=new Object[16];
int index = hashCode%arr.length;
System.out.println(index);
// 然后将该对象放入数组中对应下标的位置
LinkedList linkedList=new LinkedList<>();
linkedList.add(str);
arr[index]=linkedList;
System.out.println(Arrays.toString(arr));
System.out.println("---------------------------------------------");
// 现在又要往数组中添加一个对象
String str2=new String("r");
System.out.println(str2);
int hashCode2 = str2.hashCode();
System.out.println(hashCode2);
int index2=hashCode2%arr.length;
System.out.println(index2);
if(arr[index2]!=null){// 不为null的话表示已经存在元素了,采用链地址法,将地址相同的对象挂在后面
LinkedList list = (LinkedList)arr[index2];
list.add(str2);
}else {
LinkedList list=new LinkedList<>();
list.add(str2);
arr[index2]=list;
}
System.out.println(Arrays.toString(arr));
}
}
发现index最后得出都是2,发生了冲突
使用了扰动算法,代码如下:
public class Demo2 {
public static void main(String[] args) {
String str = new String("abc");
System.out.println(str);
// 获取str的hashCode值
int hashCode = str.hashCode();
System.out.println(hashCode);
// 将获得的所有对象存放到一个长度为16的数组中,满足使用位运算的情况,length是2的n次方
Object[] arr = new Object[16];
int index = hash(str) % arr.length;
System.out.println(index);
// 然后将该对象放入数组中对应下标的位置
LinkedList linkedList = new LinkedList<>();
linkedList.add(str);
arr[index] = linkedList;
System.out.println(Arrays.toString(arr));
System.out.println("---------------------------------------------");
// 现在又要往数组中添加一个对象
String str2 = new String("r");
System.out.println(str2);
int hashCode2 = str2.hashCode();
System.out.println(hashCode2);
int index2 = hash(str2) % arr.length;
System.out.println(index2);
if (arr[index2] != null) {// 不为null的话表示已经存在元素了,采用链地址法,将地址相同的对象挂在后面
LinkedList list = (LinkedList) arr[index2];
list.add(str2);
} else {
LinkedList list = new LinkedList<>();
list.add(str2);
arr[index2] = list;
}
System.out.println(Arrays.toString(arr));
}
/**
* 返回使用了扰动算法的hashCode
*
* @param k 要计算hashCode值的对象
* @return 返回使用了扰动算法的hashCode
*/
static int hash(Object k) {
int h = 0;
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
}
其中hash()方法内的代码就是JDK中hash()方法的源码,对hashCode值进行扰动计算。
发现原来冲突的两个对象,现在不冲突了,下标index变成了2和5。
下面来看看扰动算法的每一步结果:
"abc" | "r" | |
---|---|---|
k.hashCode()得到的十进制值 | 96354 | 114 |
k.hashCode()转换的二进制值 | 0000 0000 0000 0001 0111 1000 0110 0010 | 0000 0000 0000 0000 0000 0000 0111 0010 |
h=0 | 0000 0000 0000 0000 0000 0000 0000 0000 | 0000 0000 0000 0000 0000 0000 0000 0000 |
h^=k.hashCode() | 0000 0000 0000 0001 0111 1000 0110 0010 | 0000 0000 0000 0000 0000 0000 0111 0010 |
h>>>20 | 0000 0000 0000 0000 0000 0000 0000 0000 | 0000 0000 0000 0000 0000 0000 0000 0000 |
h>>>12 | 0000 0000 0000 0000 0000 0000 0001 0111 | 0000 0000 0000 0000 0000 0000 0000 0000 |
h ^= (h >>> 20) ^ (h >>> 12) | 0000 0000 0000 0001 0111 1000 0111 0101 | 0000 0000 0000 0000 0000 0000 0111 0010 |
h >>> 7 | 0000 0000 0000 0000 0000 0010 1111 0000 | 0000 0000 0000 0000 0000 0000 0000 0000 |
h >>> 4 | 0000 0000 0000 0000 0001 0111 1000 0111 | 0000 0000 0000 0000 0000 0000 0000 0111 |
return h ^ (h >>> 7) ^ (h >>> 4) | 0000 0000 0000 0001 0110 1101 0000 0010 | 0000 0000 0000 0000 0000 0000 0111 0101 |
h ^ (h >>> 7) ^ (h >>> 4) % 16 | 0000 0000 0000 0000 0000 0000 0000 0010 | 0000 0000 0000 0000 0000 0000 0000 0101 |
转换成十进制 | 2 | 5 |
所以hash(key)扰动函数是对key的hashCode进行扰动运算,让高位也参与运算,让分布更加散列,最终达到降低哈希冲突的目的。
注意:这是JDK1.7中的hash方法,而1.8变化较大。
总结:
参考博客:
全网把Map中的hash()分析的最透彻的文章,别无二家。
Java高级之1.7版本JDK中的HashMap的indexFor()方法