小生近来翻看HashMap的源码，颇有些领会。借此机会，聊以共享。小生才疏学浅，文中如有不妥之处，望各位看官不吝赐教。小可拜谢！
本文将从以下几个方面，浅谈HashMap
- HashMap的数据结构
- HashMap的扩容机制
- HashMap的存储过程
##一，HashMap的数据结构
在研究HashMap的特性前，不得不分析它的底层数据结构。Java中，常见的数据结构有数组，链表等。如图
为了弄清HashMap是属于哪种数据结构，这里通过一段代码：
public class HashMapDemo {
public static void main(String[] args) {
Map<String,Object> hm = new HashMap<String,Object>();
hm.put("demo","HashMap");
}
}
笔者使用的是IDEA编辑器，鼠标选中put方法，Ctrl+鼠标点击即可查看原码；
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
这里可以看到，传入的key和value，经过put方法处理，返回一个putVal方法的处理结果，这里接着查看putVal的源码
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;
}
看到这么长的一段源码，又没有中文注释，有么有像笔者一样头疼呢？其实这里暂时只需要注意这行代码就行了
Node<K,V>[] tab; Node<K,V> p; int n, i;
首先这里定义了一个数组，这个很容易看出来，然后，Node<K,V> p 这东西是个什么鬼？不要急，咱们接着往下看（注意下面）
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
是不是又头疼了？ 好了，科普一下，Node–节点（计算机网络），不要怀疑小编的英文水平，毕竟我也是装了金山词霸的人（不是打广告，金山没有给我广告费），好了，闲话不多说，解析代码：看上面定义的几个变量,hash可以理解为一个特殊的编码，经过hash算法处理，key-value就不需要解释了，自己手动输入的键值对；
Node<K,V> next 这个才是最难理解的，想想上面的数据结构，原来这就单向链表的一个节点，至此，可以弄清楚网上说的HashMap的底层是数组和单向链表是怎么来的了吧。下面是一张简图，可以辅助理解
2. HashMap的扩容机制
在了解了HashMap的数据结构之后，我们有必要再去了解一下其存储数据的方式，以及扩容机制：
因为HashMap特殊的数据结构，我们首先关注的就是数组的默认长度，这个相信很多人都
会说：“这个我知道，16 嘛 ”，那这个是怎么来的呢？其实，在源码中就已经定义了：
`static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16`
然后，我们就又有疑问了，在存储的时候，如果数组长度不够怎么办呢？源码上提供了解决方案
static final float DEFAULT_LOAD_FACTOR = 0.75f;
代码中定义了一个负载因子，数组初始长度是16，当数组使用的长度超过16*0.75，也就是超过12的时候 ，数组就会自动扩容（乘以2，后面会说为什么是2不是其他的数字）。我们接着看源码
static final int TREEIFY_THRESHOLD = 8;
这里定义了一个常量，它是干什么的呢？和数组一样，链表在超过一定个数的时候也会“变形”，这里定义的常量就是链表所能存放的最大节点数，看图
接着，源码中又定义了另外的一个常量，这个又是干嘛的呢？这个其实就是当红黑树的节点移除一部分后，如果剩下的节点数小于6，那么红黑树就会转换成链表，以保证性能最优。
static final int UNTREEIFY_THRESHOLD = 6;
3.HashMap的存储过程
**上面解释了HashMap的数据结构和扩容机制，那么我们在存储key-value键值对的时候，到低要怎么存呢？是放在数组中还是放在链表里？具体放哪一个位置呢？**
首先，要明确一点，数据在存储的时候是根据 数组下标（index）来的
那么这个下标是如何计算的呢？
上面已经解释过，HashMap是的数据结构是数组+单向列表，且数组的的默认初始长度是16。那
么我们只需要通过算法将键值对的存储下标定在0-15之间的一个整型数据即可。源码中提供了这
样的方法：
（1）通过hashCode方法得到一个整数
（2）通过异或的方式得到0-15的整数
具体操作如下：
源码中，
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
这里可以看到，在集合中插入一条数据时，会调用hash(key)这个操作，接着看hash的源码
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里可以看到：
当key不为null时，会调用hashCode这个方法，返回当前key的hash码
比如：
System.out.println("demo".hashCode()); //3079651
这里会返回一个32位的二进制编码（转换成十进制是3079651）
(h = key.hashCode()) ^ (h >>> 16)这段代码是让32位编码的高16位和第十六位进行异或
尽可能的避免数组下标相同（后面会详解）。
下面接着看 putVal方法的源码，这里会做详细的解释：
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//这段代码是判断当前的HashMap是否为空，如果为空则会调用resize()方法，将数组长度定为默认长
度（16）
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//这里采用默认长度16-1（数组下标范围）按位与hash值（上面计算的hashCode高16位和低16位
异或值）由于15的二进制码是0000 1111，hash值的后四位和0000 1111的与，值的范围在
0000 0000 ~0000 1111之间（现在解释为什么扩容一定是二倍而不是其他的倍数：初始容量是16
乘以2以后，减去1得到的二进制就是0001 1111的形式 ，后面全是1，前面全是0，能保证运算完后
下标的范围在0-31之间，不会造成空间的浪费），这样就算出了
键值对要存放的位置（下标），然而这种方式可能会导致 多个键值对都存放在同一个下标，其他的
下标分配不均匀的问题。因此就需要 hash值尽可能不一致 这就是上面使用hashCode高16位和低16
位异或值作为 hash值的原因。
//如果当前数组下标处并没有存放键值对，则将键值对放入这个下标对应的位置。
但是如果当前的位置已经有值了又该怎么处理呢？
如果这个位置已经有了值，则需要比较key值是否相等，如果相 等，则用现有的值替换原来的值并将
原来的值返回；如果key不相等，则会把键值对存在当前下标对应的链表中（存储时也要做上面判
断），当链表的节点数超过8时，则会将链表转换成红黑树。代码如下
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;
}
}
最后，贴上几张手绘原理图，仅供参考
1525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
