HashMap源码分析
transient Node<K,V>[] table;
数据结构：数组+链表+红黑树 // 红黑树是1.8引入
/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
容量为什么是2的幂次？
无论如何，我们希望元素存放的更均匀。
从后面[hash](#hash(Object key))的实现可以看出来n-1二进制是全1的，这样做与运算就避免了因为该值产生的多余的碰撞。所以相比别的值而言，采用2的幂次能有效提高插入查询等的效率。
put(K key, V value)
发现一篇博文，https://blog.csdn.net/visant/article/details/80045154，里面的图很好地说明了put()整个流程。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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 ((p = tab[i = (n - 1) & hash]) == null) // 不存在hash碰撞
tab[i] = newNode(hash, key, value, null);
else { // 存在hash碰撞，这里是采用链地址法
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) // hash和key都相同，就是更新，不管它是啥类型的节点，反正它是第一个节点
e = p;
else if (p instanceof TreeNode) // 是红黑树节点，调用putTreeVal()
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);
// 链表长度大于某个值时，调用treeifyBin()将链表转红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// hash和key都相同，就是更新
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
...
}
...
}
首次我们来计算hash值[hash](#hash(Object key))，然后通过tab[i = (n - 1) & hash]找到bucket位置，存储Map.Entry对象（包含键和值）。更具体地，(n - 1) & hash所作的运算其实就是取hash的的后(log_2n)位。也就是取低位哦！
为什么不直接用hash值，而是采用与运算/取低位？
hash值可是32位呢，这么大，tab内存不够的呀~
那为何是按位与而不是取模？取模也可以很好地分散啊~int index =hash%Entry[].length;
按位与比取模效率更高。位运算直接对内存数据进行操作，不需要转成十进制。
具体地，我们可以看反汇编的结果
; c = a & (b-1);
mov eax,dword ptr [ebp-8]
sub eax,1
mov ecx,dword ptr [ebp-4]
and ecx,eax
mov dword ptr [ebp-0Ch],ecx
; d = a % b;
mov eax,dword ptr [ebp-4]
cdq
idiv eax,dword ptr [ebp-8]
mov dword ptr [ebp-10h],edx
可以看到，&操作用了3mov+1and+1sub，而%操作用了2mov+1cdp+1idiv；前者只需5个CPU周期，而后者至少需要26个CPU周期。
插入null如何处理？
hash()会为0，所以值会存在tab[0]的位置上。
hash(Object key)
static final int hash(Object key) {
int h; // 是一个32位的int值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
计算出key的哈希值h，然后将哈希值h无符号右移16位，再与原来的哈希值h做异或^运算。也就是说，现在的低位16是原来的高位16与低位16的异或结果！结合我们找bucket位置的时候是取低位，这样就保证了取的低位里面有所有hash的信息！
get(Object key)
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) // 是红黑树节点，getTreeNode()
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;
}
这里和put()方法一样，都是先找到bucket位置，然后进行3部分的判断。
containsKey(Object key)
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
能够get(Object key)，当然能够判断是否包含Object key啦！调用的子方法同get()！
resize()
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) { // 如果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) // 如果oldCap为0，如果oldThr不为0，这个threshold就是初始容量
newCap = oldThr;
else { // 如果oldThr也为0，那么初始容量就是DEFAULT_INITIAL_CAPACITY
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) {
...
}
}
return newTab;
}
下面是红黑树的部分，先放着QAQ，回头看看这个数据结构。
putTreeVal(HashMap<K,V> map, Node<K,V>[] tab, int h, K k, V v)
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h) // 红黑树中根据hash值、key值找结点
dir = -1;
else if (ph < h)
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk))) // 找到则返回此节点
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) { // 没找到时
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn); // 创建一个结点
if (dir <= 0) // 比较
xp.left = x;
else
xp.right = x;
xp.next = x; // 插入
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x)); // 调整
return null;
}
}
}
}
treeifyBin(tab, hash)
将链表转为红黑树。
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
// 此处才是真正的转为红黑树
hd.treeify(tab);
}
}
补充内容
解决 hash 冲突的常见方法
a. 链地址法：将哈希表的每个单元作为链表的头结点，所有哈希地址为 i 的元素构成一个同义词链表。即发生冲突时就把该关键字链在以该单元为头结点的链表的尾部。
b. 开放定址法：即发生冲突时，去寻找下一个空的哈希地址。只要哈希表足够大，总能找到空的哈希地址。
c. 再哈希法：即发生冲突时，由其他的函数再计算一次哈希值。
d. 建立公共溢出区：将哈希表分为基本表和溢出表，发生冲突时，将冲突的元素放入溢出表。
线程安全
HahMap不是线程安全的。怎么做能使HashMap线程安全（其实考到了并发包的东西）？
方法一：通过Collections.synchronizedMap()返回一个新的Map，这个新的map就是线程安全的。 这个要求大家习惯基于接口编程，因为返回的并不是HashMap，而是一个Map的实现。
方法二：重新改写了HashMap，具体的可以查看java.util.concurrent.ConcurrentHashMap. 这个方法比方法一有了很大的改进。