JDK8中 HashMap原理与实现
HashMap原理及实现 JDK1.8
1、简介
HashMap是Java集合框架的Map实现类，以键值对的形式存储数据。
基本使用如下：
Map<String, Integer> map = new HashMap<>();
map.put("语文", 98);
map.put("数学", 48);
map.put("英语", 68);
map.put("物理", 78);
map.put("化学", 66);
for(Map.Entry<String, Integer> entry : map.entrySet()){
System.out.println(entry.getKey() + ": " + entry.getValue());
}
执行结果如下所示，可见其输出顺序与加入顺序不同。
物理: 78
数学: 48
化学: 66
语文: 98
英语: 68
2、存储结构及分析
其中链表节点Node(hash(key), key, value, nextNode),
树节点中包含了parent, left,right,prev和next节点的引用。
3、几个重要参数
容量(Capacity)、负载因子(Load factor)、树化阈值（TREEIFY_THRESHOLD）
容量：数组的长度，也即桶的个数，默认最小容量是16.且容量大小必须是2的次幂（方便后面通过hash计算节点位置）。
负载因子：数字的容量达到长度*负载因子时，就需要扩容，数组加倍。
树化阈值：JDK8中，当链表中元素超过树化阈值时，会将链表转换成红黑树存储。阈值为8.
4、put（）方法
- 添加节点的步骤
- 计算key的hash，然后通过hash计算出节点的存放位置，即下标。
- 如果没有碰撞，则直接放入桶中
- 如果碰撞，将节点放入链表中，
- 如果链表长度超过8，则将链表转换成红黑树，
- 如果存在key相同，则直接覆盖原始值，
- 如果桶满（达到容量*装载因子）,则扩容，进行rehash（resize）。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// tab为空则创建数组，此处调用的resize方法
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// i = (n-1) & hash 计算下标，如果未碰撞，则直接存储节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {//发生了碰撞，则存储在链表或者树中
Node<K,V> e; K k;
// 如果数组上的那个节点hash相同，且key相同，则e指向该节点，等待后面覆盖
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;
}
//当key相同时，直接替换，此时e已经指向某个节点，直接退出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//检查e的null，进行覆盖操作，并且直接返回被覆盖的节点
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;
}
5、 get（）方法
Get方法比较简单， 先检查下标位置的节点，然后在该节点next中检索。注释见代码。
若在树中，log(n)，链表中log(n).
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
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;
}
6、hash计算分析
以默认数组容量16为例，进行说明：
- 一般将Key的hash映射到0-15上，直接进行模运算即可，但是jdk中使用了巧妙的位运算来完成。
可以看下面源码，高16bit不变，低16bit和高16bit做了一个异或，主要是考虑到n较小时，参与散列的元素只有后面n位，
较容易碰撞，所以选择将高16bit和低16bit异或了一下。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
- 下标计算： （n-1） & hash
n是数组的长度，一定是2的次幂。所以n-1的二进制有效位全是1，例如0001111=15
与hash进行按位与操作时，产生的数的范围也是0~15,与模运算效果相同，但是模运算计算开销大。
7、数组扩容
在添加节点的最后一步，会进行数组容量的判断，超过阈值后，则进行数组扩容，将长度扩大一倍。并需要重新计算位置，将元素重新放到新数组中。
理论上可以重新利用（new_n - 1） & hash计算的，但是当n为2的次幂时，且是扩大2倍，使得上述计算结果只会存在两种情况，
一、原位置、二、原位置+原容量oldCap。
这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，
因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = 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;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
8 总结
HashMap内部是由数组+链表+红黑树实现的。
遍历的顺序和加入的顺序不同，LinkedHashMap一致。
冲突的解决办法： 链接法（上述方法）、开放地址法。
链表查询为O(n)，转换为红黑树后为O(logn)