什么是HashMap
HashMap在应用层的使用非常广泛，用来储存键值对。它使用哈希函数来做索引因此性能较高。同TreeMap相比，HashMap的插入、删除、查询时间复杂度在理想情况下达到O(1)。JDK1.8后，HashMap采用了TreeMap优化链表，因此极端情况下插入、删除、查询的效率也比线性好，达到O(lgN)。而JDK1.8以前，HashMap使用链表处理哈希碰撞，所以极端情况时间复杂度为O(N)。
什么情况用HashMap
当开发者想要储存有关联的键值对时，在不考虑并发安全性和有序性的前提下，应该使用HashMap。
例如:
public static class Node implements Comparable<Node>{
public Node(int v){
this.value = v;
}
public int value;
@Override
public int compareTo(Node o) {
return this.value-o.value;
}
}
public static void main(String[] args) {
Map<Node,Object> map=new HashMap<>();
map.put(new Node(6), new Object());
map.put(new Node(3), new Object());
map.put(new Node(5), new Object());
map.put(new Node(4), new Object());
map.put(new Node(1), new Object());
map.put(new Node(11), new Object());
Iterator<Node> iterator = map.keySet().iterator();
while(iterator.hasNext()){
Node n = iterator.next();
System.out.println(n.value+" , "+map.get(n));
}
}
输出结果:
5 , java.lang.Object@33909752
11 , java.lang.Object@55f96302
1 , java.lang.Object@3d4eac69
6 , java.lang.Object@42a57993
3 , java.lang.Object@75b84c92
4 , java.lang.Object@6bc7c054
HashMap运行插入的键是null，如果键是null，其哈希值为0，所以null型键值对会插入到数组的首个位置。
HashMap内部实现
基于JDK1.8分析
HashMap结构图.png
HashMap内部依赖数组、链表、红黑树实现。
数组/链表节点
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
HashMap将插入的键值对封装在Node对象中，每个Node对象含有hash值，键对象key，值对象value。当哈希值冲突后，新增的Node会被next变量指向，组成链表。当该链表的长度超过8，将其转换为红黑树节点。
红黑树节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}
容量及扩容
HashMap构造方法并没有对内部的table数组初始化，可能是为了防止未使用的情况下浪费内存。当初次执行插入，如果数组为空就会初次调用扩容方法resize()创建table数组。
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 (++size > threshold)
resize();
}
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length; //初始长度为0
int oldThr = threshold; //如果HashMap构造方指定了初始长度和加载因子，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); //默认临界值
}
}
如果未指定HashMap的构造方法参数，数组初始长度为DEFAULT_INITIAL_CAPACITY（16），加载因子为DEFAULT_LOAD_FACTOR(0.75)。开发者也可以通过HashMap的构造方法指定初始长度和加载因子。
HashMap的容量超过当前数组长度*加载因子，就会执行resize()算法，该算法将创建一个新的数组，长度是原来的两倍（旧的长度左移一位），并且将原来的HashMap数组的节点转换到新的数组。同时threshold变量也会是原来的两倍，该变量用来判断HashMap在插入后是否应该扩容。
** 疑问：为什么扩容要将原长度左移一位呢? 因为性能问题？**
插入算法
取哈希值
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
首先调用Object的hashCode()方法算出key的哈希值，该方法在native层实现。接着将key的哈希值(int型32位)无符号右移16位，即取它的高16位返回,右移后高16位变成0，原高16位移动到低16位。
取数组中的位置
再来看具体的插入putVal方法:
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);
这里n是table数组的长度，hash是key的哈希值经过高16位转低16位的int值。
这里计算节点在table数组的位置的算法是:i = (n – 1) & hash，将数组长度减1后与运算hash。这个算法就很巧妙了，记得上面说过数组的长度一定是2的幂，即使初始长度非2的幂也会强制转换为2的幂:
this.threshold = tableSizeFor(initialCapacity);
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;
}
假设传入cap=5，最后输出长度为8。加入传入cap=9，最后输出长度为16。所以n-1的二进制形式分别是111,1111。
** 用hash与(n-1)做位置运算相比%运算更高效，这可能就是HashMap数组长度为2的幂的原因吧。并且这种巧妙的设计也能保证位置i不会超过数组长度。**
非冲突的情况
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
根据key算出hash值后，再通过** “(n-1)&hash” **算出键值对在数组中对应的位置，如果table[i]为空直接将键值对封装到Node插入table[i]。
冲突的情况
首个位置的键与新插入的键相等
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
当table[i]非空，且key==table[i].key 或者 key非空，key.equals(table[i],key)。说明table[i]上的节点的键key等同于新插入的键，这种情况下令新插入的节点为table[i]。下面会将table[i]中的value替换为新插入的value。
首个位置是红黑树的节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
上面说到，如果哈希表发生了哈希碰撞，冲突的节点会插入到以table[i]为链表头的尾部。如果该链表长度超过8，会转换成红黑树。因此table[i]既可能是链表头，也可能是红黑树的根部。
如果tablei是红黑树的节点，说明该hash值冲突的节点冲过了8个，将新的键值对插入红黑树。
首个位置是链表节点
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) { @1
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash); @3
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
@2
break;
p = e;
}
@1 如果遍历到链表的末尾，说明遍历的过程中未找到key相等的节点，将键值对插入末尾
@2 如果遍历链表的过程中，存在哈希值一致，引用相等或equals相等的节点，终止遍历，新键值对的值会替换这个节点上原来的值。
@3 在链表末尾插入新节点后，链表的长度达到8，此时方法treeifyBin(tab, hash)将链表转换为红黑树
替换原节点中的Value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
对于已经在链表或红黑树存在的节点，只会替换原Value就返回。
插入后的扩容
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
在前面已经描述过，当HashMap的size超过了 长度*负载因子，就会执行resize()方法扩容，将原table数组长度扩大两倍。
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; @1
else if (e instanceof TreeNode) @2
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order @3
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;
}
}
}
}
}
这段代码将原数组中的元素插入到新数组中，具体表现为:
@1 将非链表非红黑树的节点计算新位置后重新插入新数组。
@2 将原红黑树插入新的数组
@3 将原链表插入新的数组
这里要注意的是，扩容后(n-1)的值在高一位多了1，因此原来的链表和红黑树的节点的位置可能出现高一位多了1，所以不能简单的直接将头节点移动到新数组,需要重新计算位置。而哈希值不需要重新计算，所以这可能就是** (n-1)&hash **这个算法的好处吧。
取出算法
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;
}
取出算法其实就是插入算法的逆向过程，你可能直接从table[i]中取走键值对，也可能是红黑树或者链表中的一个节点。
要注意的是只满足equlas相等并不能有效取出元素，还必须满足哈希值相等，所以要考虑重写key的hashCode()方法。
HashMap小结
- JDK1.8以后用红黑树对HashMap的链表做了优化，因此使得HashMap的最差性能从O(n)提升到O(lgn)。
- 扩容是一件很耗费性能和内存的事情，除了要创建新数组，还要将原数组中的链表或红黑树重新计算位置（不重新计算哈希值），然后插入新的数组。
- 如果HashMap创建时就知道对面的是多大容量的数据，可以指定初始容量和负载因子。
- HashMap和TreeMap都是非线程安全的，建议使用ConcurrentHashMap处理并发安全问题。Hashtable的并非像ConcurrentHashMap对数组的每个位置加锁，而是对操作加锁，性能较差。另外Collections.synchronizedMap(map)这种方法也是在Map对象的方法上装饰了synchronized关键字，因此同Hashtable性能较差。
- LinkedHashMap继承于HashMap，替HashMap完成了输入顺序的记录功能，所以要想实现像输出同输入顺序一致，应该使用LinkedHashMap。
