HashMap 1.8源码疑惑及解答

最新推荐文章于 2021-05-18 18:41:17 发布

琴瑟裹腹

最新推荐文章于 2021-05-18 18:41:17 发布

阅读量130

点赞数 1

文章标签： HashMap原理 jdk1.8

HashMap中有个对象 transient Entry[] table；这个是存储数据的地方，但是为什么要加上关键字transient呢？

打个比方说, 向HashMap存一个entry, key为字符串"STRING", 在第一个java程序里, "STRING"的hashcode()为1, 存入第1号bucket; 在第二个java程序里, "STRING"的hashcode()有可能就是2, 存入第2号bucket. 如果用默认的串行化(Entry[] table不用transient), 那么这个HashMap从第一个java程序里通过串行化导入第二个java程序后, 其内存分布是一样的. 这就不对了. HashMap现在的readObject和writeObject是把内容输出/输入, 把HashMap重新生成出来. "Object.hashcode()是native方法, 不同的JVM里可能是不一样的." -- 比如你有两个java进程, 那么这两个进程里的同一个字符串的hashcode()可以是不一样的.

HashMap中tableSizeFor的一个精巧的算法

代码如下：
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
tableSizeFor(int cap)是hashMap中的一个Static函数，主要功能是返回一个比给定整数大且最接近的2的幂次方整数，如给定10，返回2的4次方16.
这个算法的原理是什么呢：
我们首先假定cap也就是给定数的的形式为00..01XXXXXXX,(X代表可为0也可为1，X前面的1为从最高位开始第一个为1的那一位)
首先是n |= n >>> 1;也就是n变成n与n右移一位之后异或后的值，即
n: 00..01XXXXXXX
n>>>1:00..001XXXXXX
新n： 00..011XXXXXX
也许到这里你还看不出什么结果，那接着看第二步n |= n >>> 2;也就是n变成n与n右移两位之后异或的值，即
n: 00..011XXXXXX
n>>>2:00..00011XXXX
新n: 00..01111XXXX
到这里就不用再解释了吧，这个算法不断的通过把第一个1开始后面的位变成1，本例由00..01XXXXXXX->00..011111111,最后再返回n+1;
确定哈希桶数据索引位置

//方法一：
 2 static final int hash(Object key) {   //jdk1.8 & jdk1.7
 3      int h;
 4      // h = key.hashCode() 为第一步 取hashCode值
 5      // h ^ (h >>> 16)  为第二步 高位参与运算
 6      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 7 }
 8 //方法二：
 9 static int indexFor(int h, int length) {  //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
10      return h & (length-1);  //第三步 取模运算
11 }


HashMap的put方法实现


思路如下：
1.table[]是否为空
2.判断table[i]处是否插入过值
3.判断链表长度是否大于8，如果大于就转换为红黑二叉树，并插入树中
4.判断key是否和原有key相同，如果相同就覆盖原有key的value，并返回原有value
5.如果key不相同，就插入一个key，记录结构变化一次

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 2                    boolean evict) {
 3 //判断table是否为空，如果是空的就创建一个table，并获取他的长度
 4         Node<K,V>[] tab; Node<K,V> p; int n, i;
 5         if ((tab = table) == null || (n = tab.length) == 0)
 6             n = (tab = resize()).length;
 7 //如果计算出来的索引位置之前没有放过数据，就直接放入
 8         if ((p = tab[i = (n - 1) & hash]) == null)
 9             tab[i] = newNode(hash, key, value, null);
10         else {
11 //进入这里说明索引位置已经放入过数据了
12             Node<K,V> e; K k;
13 //判断put的数据和之前的数据是否重复
14             if (p.hash == hash &&
15                 ((k = p.key) == key || (key != null && key.equals(k))))   //key的地址或key的equals()只要有一个相等就认为key重复了，就直接覆盖原来key的value
16                 e = p;
17 //判断是否是红黑树，如果是红黑树就直接插入树中
18             else if (p instanceof TreeNode)
19                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
20             else {
21 //如果不是红黑树，就遍历每个节点，判断链表长度是否大于8，如果大于就转换为红黑树
22                 for (int binCount = 0; ; ++binCount) {
23                     if ((e = p.next) == null) {
24                         p.next = newNode(hash, key, value, null);
25                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
26                             treeifyBin(tab, hash);
27                         break;
28                     }
29 //判断索引每个元素的key是否可要插入的key相同，如果相同就直接覆盖
30                     if (e.hash == hash &&
31                         ((k = e.key) == key || (key != null && key.equals(k))))
32                         break;
33                     p = e;
34                 }
35             }
36 //如果e不是null，说明没有迭代到最后就跳出了循环，说明链表中有相同的key，因此只需要将value覆盖，并将oldValue返回即可
37             if (e != null) { // existing mapping for key
38                 V oldValue = e.value;
39                 if (!onlyIfAbsent || oldValue == null)
40                     e.value = value;
41                 afterNodeAccess(e);
42                 return oldValue;
43             }
44         }
45 //说明没有key相同，因此要插入一个key-value，并记录内部结构变化次数
46         ++modCount;
47         if (++size > threshold)
48             resize();
49         afterNodeInsertion(evict);
50         return null;
51     }

HashMap的get方法实现

实现思路：

1.判断表或key是否是null，如果是直接返回null

2.判断索引处第一个key与传入key是否相等，如果相等直接返回

3.如果不相等，判断链表是否是红黑二叉树，如果是，直接从树中取值

4.如果不是树，就遍历链表查找

final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//如果表不是空的，并且要查找索引处有值，就判断位于第一个的key是否是要查找的key
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
//如果是，就直接返回
return first;
//如果不是就判断链表是否是红黑二叉树，如果是，就从树中取值
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果不是树，就遍历链表
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}

扩容机制

我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。

hashMap 1.8 哈希算法例图1

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：

hashMap 1.8 哈希算法例图2

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：

jdk1.8 hashMap扩容例图

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。