(转载请注明出处)
HashMap在实际开发中用到的频率非常高，面试中也是热点。
所以决定写一篇文章进行分析，希望对想看源码的人起到一些帮助，看之前需要对链表比较熟悉。
PS：都是我自己的理解，如有不同理解勿喷，谢谢大家
此处分析的HashMap版本为Java1.8中的版本。
开始之前我们先要知道HashMap存储的是key-value形式的数据，然后我们要知道他是散列表数据结构实现的。
一、散列表
关于散列表（也叫哈希表），先上图（图片来源百度），
上图就是散列表的结构图，可以看到，最左边一列，一列连在一起的格子，以及从0开始的下标，是不是很熟悉？
没错这就是我们熟悉的数组（线性表）了，我们再看右边，右边也是一个我们常用的数据结构，链表。
数组和链表都有各自的缺点：
1、数组删除、插入性能不佳，寻址性能极优
2、链表寻址性能不佳，删除、插入性能极优
散列表是将两者的优点结合所诞生的一种数据结构
对上面的话进行一下总价：散列表 = 数组（线性表）+链表
二、HashMap.Node内部类
准备工作完成了，下面将开始进行源码分析（以下源码皆是从1.8版本HashMap中复制而来）：
下面是HashMap开始定义一个静态内部类，Node<K,V>。
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; } }
直接看属性
final int hash;
final K key;
V value;
Node<K,V> next;
key和value就是put的时候传入的参数
next，可以看出来，存的是另外一个节点的引用，这个就是单向链表的实现了，可以将链表中下一个节点赋值给next，这样就能通过当前节点拿到next中存储的下一个节点了
hash ，用来存储key的哈希值
不难看出HashMap.Node的对象就是HashMap存储的实际数据
再看HashMap中用Node定义了些什么对象，寻找HashMap中Node类型的成员变量，我们可以找到下面这行代码。
transient Node<K,V>[] table;
因为Node中有next属性的存在，所以每个Node都可以作为头结点去存储一个链表数据结构。
我们可以把Node理解为一个存储了key、value、hash的链表
而 Node[ ] table，即为链表的数组
需要注意的是，table在这里并没有初始化。
三、put方法，hash碰撞和扩容
我们继续往下，找我们熟悉的put方法，代码如下：
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
可以看到，put中是直接调用putVal方法的，其中有个需要注意的点，细心的朋友可能已经发现了，在调用putVal时第一个参数，hash(key)，hash方法如下：
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
这里可能有人会好奇为什么要计算key的hash值，以及为什么不直接使用 key.hashCode() 来获取哈希值
这是因为，hashmap 的 put 方法和 arraylist 的 add 方法不同，arraylist 是将上一个节点的下标+1，然后往这个+1下标中存数据 。而这种连续下标的存储方式在删除、插入时会带来下标前移和后移的性能消耗。
散列表中的数组是非连续存储的。
我们用index代表下标，那么就有类似：
index 0 有数据
index 1 没数据
index 2 没数据
index 3 有数据
怎么决定每个元素的存储位置?
hashmap采用的方法是通过hash等一系列算法，使用key计算出一个index，然后进行数据存取。
index如何计算？
假设数组长度是10，那么下标范围就是 0-9
所以要做的事情，就是根据 hash 得到一个 0-9 的数据，说到这里应该已经有人知道怎么做了，这时我们只需要 hash%10 ，就能得到一个 0-9 之间的数据，也就是我们计算出来的下标。
但是，事情往往没有那么简单
我们直接看源码，看看到底如何操作的，这里我把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; }
下面将这段代码的流程说明一下，比较复杂，散列表的核心逻辑基本都在这里
1、
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
判断当前table是否初始化（table），如果没有，则调用 resize() 方法来给数组初始化一个大小，因为 Node[ ] table 在定义的时候并没有初始化，resize() 方法的具体代码下文也会贴出来
2、
if ((p = tab[i = (n - 1) & hash]) == null)
这里做了两个操作，第一个是 (n - 1) & hash ，这一句就是计算下标的语句，其中 n 是数组长度。，这里并没有采用我们前面说的 hash % n ，这和HashMap的特性有关，下文会解释。
第二个操作是判断计算出的下标是不是已经存了数据，如果没有，就直接put到这个下标（代码中是先用一个临时变量 e 存储了旧节点，在最后一个if的时候判断了旧值是否为空，为空就把新值写进e.value中）。
如果已经有值，说明两个节点计算的下标相同，我们重点分析这里。
3、哈希碰撞
两个节点计算的下标相同，则为hash碰撞。
碰撞发生，只能说明计算的下标相同，并不能说明key或者hash相同，所以接下来应该是对hash和key进行进一步对比，如下：
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
如果key相同，为了满足hashmap key唯一的特性，则新值覆盖掉旧值。
如果key不同，则以链表的形式追加,A.next = B，如下图：
如果再有第三个节点，则 B.next = C，形成一个长度为3的链表，依次类推。
注意，在往后追加之前，会依次遍历链表上的每一个节点，如果发现其中某个节点的key与要追加的key相同，则直接覆盖。
此外，1.8版本中，hashmap新增了红黑树特性，如果链表长度超过8（包含8）则将链表转换为红黑树，该操作是为了解决链表过长时的寻址和查找性能，代码如下：
（红黑树此处不做详细介绍，它是一个非完全平衡二叉树）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
4、扩容 与 resize() 方法
看putVal方法的最后一段
++modCount;
if (++size > threshold)
resize();
这里又调用了，初始化数组时候的 resize() 方法。
在Java中，数组的大小是固定的，不能动态增加，所以如果初始化的时候为其分配16个对象的空间，那么一旦这16个格子被占满，则后续的节点都会一直往链表上追加，
1.7版本会导致链表过长，严重影响存取性能，1.8加入红黑树以后，性能有所优化，但是性能依旧不理想（对比HashMap和HashTable性能即可），
所以为了保证存取的性能，hashmap会动态的对数组大小进行扩容。
我们来接下来看一下，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) { 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; }
resize()代码略长，我们就说一些关键地方吧，在代码中，我们可以看到一个名为threshold的变量，这是HashMap的一个成员变量
顾名思义，它是一个临界值，扩容的临界值，当 HashMap的size 大于 threshold 就会进行扩容
这里有一点需要注意，判断时使用的是HashMap的size，而不是Node[] table下标被占用的数量，因为有些数据可能是以链表的形式存储，没有直接放入Node[] table中
而HashMap.size是map中存储的总节点数，包括链表中的节点
我们找到threshold的定义代码：
/** * The next size value at which to resize (capacity * load factor). * * @serial */ int threshold;
注释可以看出来
threshold = capacity * load factor
其中capacity是容量，是Node[ ] table的 length ，loadFactor叫做 “负载因子”， 也就是一个比例，size达到length的百分之多少就扩容，这个百分比就是 loadFactor。
查看构造方法，发现 loadFactor默认0.75，并提供了可以多参构造方法设置loadFactor。
static final float DEFAULT_LOAD_FACTOR = 0.75f; public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); }
上面代码最后一行，有一个tableSizeFor()方法，这个方法的作用是根据传入的 initialCapacity，得到一个 >=initialCapacity 的最小 2 的 n 次幂
这是hashmap的一个大小特性(实际上是 Node[ ] table 的大小特性)，永远是 2的n次幂，具体是什么意思呢，举个例子，你调用构造方法传的大小如果是10，实际大小是16，如果传17、30，则实际大小是32。
tableSizeFor方法涉及无符号位移运算，此处不做分析，有兴趣的朋友可以自己研究
另外，注意一下，在构造方法中 tableSizeFor 计算的大小被直接赋值给了 threshold ，而不是threshold = tableSizeFor (initialCapacity) * loadFactor
原因是在构造方法中，并没有对 Node[ ] table 这个成员变量进行初始化，table的初始化被推迟到了putVal方法里调用的 resize() 中，在resize()方法中会对threshold重新计算，代码如下：
float ft = (float)newCap * loadFactor;
知道“负载因子”，临界值等概念以后我们再回头看 resize() 方法，
newThr = oldThr << 1; // double threshold
可以看到，扩容后的大小是扩容前的大小左移一位，左移一位的效果和乘以2的效果一样，所以是double倍的扩容，这样也保持了大小为 2 的 n 次幂的特性。
扩容流程我这里文字描述一下，大家比对着代码看就行了，就不再重复贴resize的代码了
1、创建一个新的Node数组，大小为之前的两倍
2、遍历旧的Node数组中的节点，如果节点之后有链表或红黑树，则遍历链表和红黑树
3、将遍历的每一个数据根据新的数组的大小，通过(newLength - 1) & hash重新计算下标
4、按照新的下标将数据放入新的数组中
PS：因为大小变化所以下标计算也出现了变化，之前碰撞的可能扩容后不再碰撞，之前不碰撞的可能扩容后碰撞
四、其他
1、 (n-1)&hash 计算下标，而不是 hash%n
使用这个计算下标是基于hashmap的大小特性，在n等于 2的n次幂 时，
(n-1)&hash = hash%n
可以通过代入多组数据验证
2、put方法的返回值
很多人都不会注意这个，put方法其实是有返回值的，可以回过头再去看看一下源码。
put方法返回的是该key对应的旧的value，如果该key是第一次被put，则返回null
3、get方法
get方法也是先计算下标，然后通过下标取出这个节点，然后遍历这个节点后面的链表，直到找到key相同（equals）
4、hash方法
hash方法中之所以没有直接采用hashCode方法，是因为要提高hash值的均匀程度，减少碰撞
5、性能优化
上面提到了，扩容时会新建一个两倍大小数组，然后对旧数组中的数据进行全部重新计算下标。
上面这个扩容操作是阻塞的，也就是说，在使用HashMap时，正好插入了超过临界值的一条数据，那么这条数据的插入会比较慢，因为要等待扩容完成，如果数据较多，这个时间消耗就比较大了。
我们可以借助HashMap提供的多参构造方法进行优化，预估可能会存储的数据量，给定合适的初始大小，避免扩容，同时要避免初始化过大，以免造成不必要的空间消耗。
五、尾记
不管是源码中大量的位运算，还是红黑树的引入，都能看出作者在为了提升HashMap的一点点存取性能做出的巨大努力，其实不止是HashMap，JDK中许许多多的类都编写的很精美，值得我们一行一行的去推敲。
另：(转载请注明出处)
875
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
