前言
- hashMap源码是面试的时候经常会问到的，所以需要了解一下
- 以下所有分析都基于java 1.8
构造函数
- 可以看到，HashMap的构造函数其实就是在初始化参数
- 需要注意的点有：
-
- initalCapacity不能大于MAXIMUM_CAPACITY[默认为1<<30]
-
- loadFactor默认是0.75，当当前容量>capacity * loadFactor的时候就要进行扩容，扩容为原来的两倍
-
- threshold为大于等于initialCapacity的2的次幂值，其函数实现见下图
-
上图的算法第一眼看过去可能有点懵逼，可以配合详细的例子来理解这个算法
-
- 先假设n的二进制为01xxx…xxx
-
- 然后右移一位，得到 001xxx…xxx ，进行异或，得到011xxx…xxx
-
- 此时前面已经有两个1个，然后同理，右移两位，进行异或，得到01111xxx…xxx
-
- 以此类推，可以看到，这种方法能让最高位的1后面全变成1
-
- 最后面的结果再加一，就变成了2的次幂值
-
- 之所以无需32是因为cap是int，最大就是32位
-
需要注意的点是：第一步-1是因为如果不-1的话当出现了恰好等于2的次幂值的时候会翻倍
put方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- get方法大概是hashMap中最复杂的方法
- 在这里首先要理解一下hashMap的机制
- hash之后得到的值可能会发生冲突，当该位置为空的时候就直接put，在节点数小于TREEIFY_THRESHOLD（8）的时候为链表状态，直接插入链尾，否则的话转换为红黑树。
- 理解了这部分机制这个代码就很好理解上部分的代码了
- 红黑树这部分的代码等学习了这个数据结构再看
get方法
- 有了put方法的基础get方法也很好理解
- 但是需要注意的是get方法里面有两个设计比较巧妙需要注意的点：
取模运算（为什么容量一定得是2的次幂）
first = tab[(n - 1) & hash]
- 在hashMap中，为了使元素分布更均匀（应该是集中？），很多时候会使用取模运算
- 但是考虑在计算机二进制中的运算效率，并没有直接使用%运算符，而是使用了位操作符
- 这里只有在n为2的次幂的时候才能完美的实现取模运算
- 这也是HashMap设计很巧妙的一个点
hash(key)的源码
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
- 其实这是一个“扰动函数”
- 考虑一个问题，虽然hashMap生成的是32位随机值，但是我们做了上述的取模运算之后，它只取了低几位
- 如果我们的散列本身做的不好，很有可能带来最后低位规律性重复的问题，从而带来严重的冲突
- 所以我们将hashCode的低16位和高16位做异或，增加低位的随机性，高位的特征也被变相的保留了下来
remove方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//根据key和key的hash值，查找到对应的元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果查找的了元素node，移除即可
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果是TreeNode，通过树进行移除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果是第一个节点，移除第一个节点，将index下标的位置指向第二个节点
else if (node == p)
tab[index] = node.next;
else
//如果不是链表的第一个节点，则移除该节点
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
- remove方法根据三面的三个部分也很好理解
resize()方法
- 说实话，前面的扩容部分很好理解，我们主要来看看如果存在oldTab，如何把oldTab的数据转换到newTab上
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//1
do {
next = e.next;
//2
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//3
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//4
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
- 从注释1处的do循环我们能看出来HashMap在1.8中采用的尾插法
- 我们看代码4处一开始可能看的一脸懵逼，为什么要分lo和hi，两者又是怎么区分的？
- 其实，是这样的，我们在1.7中需要重新计算hash值然后根据hash&(length-1)计算新的位置
- 但是，我们发现如下图所示的规律：
- 如果hash的新增参与位是0，对应上述注释2处，则扩容后的位置 = 原始位置
- 如果hash的新增参与位是1，对应上述注释3处，则扩容后的位置 = 原始位置 + 扩容前的旧容量
- 所以，在JDK1.8中我们就直接采用了这个规律，不需要重新计算hash值
一些小点
其他源码
- 其余的大部分源码都是调用了上述方法的比较简单的方法
- 如果以后遇到什么问题再加
如何解决Hash冲突？
- 良好的hash算法
- 扩容机制
为什么HashMap需要使用包装类作key值？
- 内部已经重写equals(),hashCode()
- 严格遵守相关规范
- 不容易出现hash值的计算错误
- hashCode的实现不恰当，会导致严重的Hash碰撞
为什么在JDK1.8中对HashMap进行优化的时候，把链表转换红黑树的阈值是8，而不是7或者20？
- 以下来自于JDK1.8中HashMap的注释
- 由于treenode大小大约是常规节点的两倍，因此我们仅在容器包含足够的节点以保证使用才使用他们。
- 如果频繁在阈值上下波动，会造成在链表和数之间的频繁转换，效率会降低
- 容器中节点分布在hash桶的频率遵循泊松分布，>8的概率是非常小的。所以作者应该是参考了概率统计选择的阈值。
特点
- 不保证有序：
- 插入顺序 = 用户操作的顺序
- 存储顺序 = 根据hash算法计算而来
- 存储位置随时间变化：
- 扩容操作带来位置变化
需要注意
- 扩容是一个特别耗性能的操作，所以当程序员再使用HashMap的时候，初始化给一个大致的数值，避免map进行频繁的扩容。
- 负载因子是可以修改的，也可以大于1，但是建议不要轻易修改，除非情况非常特殊。
- HashMap是非线程安全的，不要在并发的环境下同时操作HashMap，建议使用ConcurrentHashMap
- JDK1.8引入红黑树大程度优化了HashMap的性能
2928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
