前言
HashMap可以说是我们用过最多的<K,V>键值对集合了。既然用得多，就得深入的了解它，同时HashMap也是ConcurrentHashMap的基础，理解了HashMap，再学习ConcurrentHashMap就事半功倍了。
基于此，本篇主要从源码层面讲解HashMap，包括数据结构、成员变量（常量）、扩容机制、核心方法，Hash冲突、JDK1.7的缺陷、JDK1.8对HashMap的改进等等，本篇以JDK1.8版本为主。
由于涉及到链表、红黑树相关的知识所以先了解下前置知识是非常有必要的，所以我挑选了两篇相关的文章：
- 图解数据结构：数组和单链表 ：这篇文章较为深入的讲解了数组和单链表相关的基本操作
- 漫画：什么是红黑树？：这篇文章作为红黑树的扫盲篇，主要关注红黑树的整体结构和作用即可
除此之外，还需要知道什么是hash（哈希）。
Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
hash是将任意长度的消息压缩到某一固定长度的消息摘要的函数。输入是任意长度，输出是固定长度。也就是说把无限的集合映射成有限的集合，所以必定存在：不同的输入，出现相同的输出。这种情况就是Hash碰撞，或者说Hash冲突。HashMap会如何处理这种冲突，本文后面会详细介绍。
JDK1.7下的HashMap
数据结构
JDK1.7中的HashMap的结构就是经典的数组+单链表结构
成员变量
/**
* 默认初始容量，必须为2的指数幂，这里的容量是指上图中左侧数组的大小
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认加载因子（load factor），用于扩容机制，0.75是经验值，一般不修改
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* Entry数组，也就是常说的桶（bucket）或者槽（slot），也就是上图中左侧的数组
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
/**
* map中键值对数量，也就是HashMap中元素的个数（注意区分size和容量）
*/
transient int size;
/**
* 阈值 (capacity * load factor)，用于扩容机制
*/
int threshold;
/**
* 加载因子，用于扩容机制
*/
final float loadFactor;
/**
* 对HashMap结构修改的次数，用于fail-fast机制
*/
transient int modCount;
以上就是HashMap中需要重点关注的成员变量（常量）。能记住最好，不然看源码的时候还得翻回来看。
核心方法&扩容机制
构造方法
先来看看HashMap的构造方法：
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;
threshold = initialCapacity;
// 此方法没有做任何事，用于子类
init();
}
可以看到HashMap的构造方法并没有做太多的操作，仅仅是给两个成员变量赋值。init()方法也没有任何逻辑，实际上这个方法是给HashMap的子类LinkedHashMap准备的。
除此之外，构造方法并没有初始化table这个成员变量，而是放入第一个元素的时候再初始化。
put方法
使用HashMap时，用得最多的两个方法便是：put(K key, V value)、get(Object key)。因此先看看put方法的源码：
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
// 添加第一个元素时，table为空，需要初始化
inflateTable(threshold);
}
if (key == null)
// 单独处理key为null的情况，也就是说key允许为null
return putForNullKey(value);
// 计算key的hash值
int hash = hash(key);
// 根据key的hash值找到其在table数组中对应的槽（slot）
int i = indexFor(hash, table.length);
// 从头结点开始遍历单链表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
// 在单链表上找到了新插入的数据（也就是新增元素和已有元素的key重复了）
// 然后把新的value赋值这个key对应的value，返回旧值。
// 也就是往HashMap中put两个同样的key，新的value会覆盖旧的value
V oldValue = e.value;
e.value = value;
// 这个方法也是为LinkedHashMap准备的
e.recordAccess(this);
return oldValue;
}
}
// 如果这行代码之前如果return了，则HashMap的结构不会被修改
// 之后的代码会修改HashMap的结构，所以modCount++
modCount++;
// 当前槽（通过hash值执行indexFor方法得到的槽索引）上没有数据或者HashMap中不包含新增数据的key
// 则需要往HashMap中添加元素，此时一定会改变HashMap的结构
addEntry(hash, key, value, i);
return null;
}
其中定位当前槽的方法：
static int indexFor(int h, int length) {
return h & (length-1);
}
这个方法执行的逻辑，就是根据key计算得到的hash值，来确定当前数据应该放在哪个槽（slot）。实际上就是执行对数组的长度取余操作，等价代码如下：
static int indexFor(int h, int length) {
return h % length;
}
可以看到，JDK用&代替了%操作，原因是&更加高效。但是要保证h & (length-1)和h % length计算出来的结果一样，需要满足一个条件：length是2的n次幂。这就是为什么HashMap的容量必须是2的n次幂。
继续往下看addEntry方法，该方法的逻辑是往HashMap中插入新的元素
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
// hashmap节点数大于阈值，并且当前槽（slot）上有元素，也就是hash冲突
// 扩容操作，容量变为原来的2倍（这里的容量是指数组长度，不是HashMap中元素个数）
resize(2 * table.length);
// 扩容完成后，重新计算新增元素key的hash值
hash = (null != key) ? hash(key) : 0;
// 重新定位新增元素所属的槽（slot）
bucketIndex = indexFor(hash, table.length);
}
// 真正执行插入操作
createEntry(hash, key, value, bucketIndex);
}
此方法包含了扩容的过程，指明了扩容的时机，值得注意的是，并不是size达到了阈值就开始扩容了，而是还需要满足当前槽（slot）上非空。
查看真正的插入操作：
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
// 用头插法将元素插入链表的头部，即使此时槽为空也是满足的，相当于空链表
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
再来看看扩容方法resize：
void resize(int newCapacity) {
// 指向扩容前的数组
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 根据新的容量开辟新的数组
Entry[] newTable = new Entry[newCapacity];
// 具体的扩容过程
transfer(newTable, initHashSeedAsNeeded(newCapacity));
// table指向新的数组
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
接着看具体的扩容过程：
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
// 外层循环遍历数组槽（slot）
for (Entry<K,V> e : table) {
// 内层循环遍历单链表
while(null != e) {
// 记录当前节点的next节点
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
// 找到元素在新数组中的槽（slot）
int i = indexFor(e.hash, newCapacity);
// 用头插法将元素插入新的数组
e.next = newTable[i];
newTable[i] = e;
// 遍历下一个节点
e = next;
}
}
}
需要注意的是，遍历单链表是从头节点开始遍历的，而转移到新数组是用的头插法，所以转移之后，单链表会反转。大致情况如下：
重点观察table[0]处的单链表结构变化。
以上便是JDK1.7中HashMap中put方法的整个逻辑，总结起来过程如下：
- 如果table没有初始过，先初始化，否则继续
- 如果key为null，执行额外处理null值的方法
- 根据key计算hash值，根据hash值和数组长度，定位对应的槽（slot）
- 从槽指向的节点作为循环起点开始遍历单链表
- 如果在单链表中找到这个key，则替换对应的value，并返回旧的value
- 循环执行结束还没找到，说明HashMap中没有这个key，维护
modCount - 判断HashMap中元素个数是否达到阈值，并且当前槽不为空，不为空执行扩容操作
- 利用头插法将元素插入单链表头部，维护
size
相信看完源码后，这几步逻辑就很清晰了。
get方法
相比于put方法，get方法就简单多了：
public V get(Object key) {
if (key == null)
// key为null的情况单独处理，与put方法对应
return getForNullKey();
// 真正获取元素的方法
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
继续跟踪getEntry方法
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
// 计算key的hash值
int hash = (key == null) ? 0 : hash(key);
// 根据key的hash值找到对应的槽（slot），作为头节点开始遍历单链表
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
根据源码可以看到get方法总共分为以下几步：
- 判断key是否为空，是的话单独处理，否则进入下一步
- 根据key计算hash值
- 根据hash值找到
table中对应的槽，指向的节点开始遍历（也就是单链表的头节点） - 遍历判断key的hash值是否相等，key是否相等，key的equals方法是否返回true。
- 如果都满足则说明找到元素，否则遍历结束后还未找到，说明HashMap中没有包含这个key的键值对
hash冲突
前文提到过hash冲突，实际上就是不同的key值，计算得到了相同的hash值。HashMap解决hash冲突的办法就是链地址法或者叫拉链法。就是文章开头所示的数组+链表的结构，有冲突的的hash值会放在同一个槽（slot）中，用链表的形式串起来。
put方法和get方法中都有一行这样的代码
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {...}
这段代码用于在单链表上判断两个元素的key是否相等，首先判断key的hash值是否相等，hash都不相等，那元素的key肯定不相等。当key的hash值相等时，还要判断key的equals是否相等，只有equals相等，key才真的相等。
为什么hash值相等，但是equals有可能不相等呢？
实际上就是hash冲突的情况，多个不同的key生成了同样的hash值。
同时，这行代码也解释了：为什么在选择HashMap的key的数据类型时，需要保证key的hash值一旦确定后，就不能变化。如果一个key存入HashMap后，key的hash值变化了，在HashMap中就再也找不到这个key了。
除了链地址法，解决hash冲突还有三种方式：开放定址法、再散列法、公共溢出区法。
存在的问题
HashMap是线程不安全的类，因为各个方法既没有加锁，也没有进行其余的保证线程安全的操作。除此之外，JDK1.7中的HashMap在多线程的情况下，扩容可能会导致死循环。这个问题在JDK1.8的HashMap中得到了解决，至于死循环何时产生，以及JDK1.8如何解决这个问题，完整的解析请参考：HashMap多线程扩容导致死循环解析（JDK1.7）
JDK1.8下的HashMap
数据结构
一个典型的HashMap数据结构如下：
JDK1.8中的HashMap的结构就是经典的数组+单链表+红黑树结构
成员变量
JDK1.8中HashMap除了有JDK1.7中HashMap中的所有变量外，还增加了几个常量：
// 链表转红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
// 红黑树退化成链表阈值
static final int UNTREEIFY_THRESHOLD = 6;
// 链表转红黑树时，数组最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
// 数组table变成了Node数组
transient Node<K,V>[] table;
核心方法&扩容机制
构造方法
先来看看HashMap的构造方法：
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);
}
除了基本的校验和赋值，并没有初始化存储数据的数组table。从这里也可以看出，即使传入初始容量，并不是真正的初始容量。初始化阈值时，调用了tableSizeFor方法，这个方法的作用是：根据传入的参数计算出最适合的2的N次幂。该方法定义如下：
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;
}
该方法计算并不复杂，主要应用了两个不太常见的运算符|=和>>>，其中|=就是或运算后再赋值，n |= n >>> 1等价于n = n | (n >>> 1)，而>>>是无符号右移运算符，即无论右移的数值是正还是负，高位均补0。比如：1000 1010 >>> 2会变成0010 0010。通过该方法，能使table数组长度（也就是槽的个数）始终为2的N次幂。
put方法
看完了构造方法，再来看看使用最多的put方法，put方法可以说是整个HashMap的精髓所在。
public V put(K key, V value) {
// 调用内部的putVal方法
return putVal(hash(key), key, value, false, true);
}
// put方法实际调用该方法
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)
// table没有初始，放入第一个元素时进行初始化
// 此处把初始化和扩容方法统一了，都叫resize
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 当前槽为空，直接把元素插入该槽
// (n - 1) & hash在讲解JDK1.7的时候已经详细讲过了，是为了根据key的hash值找到对应的槽，相当于取余操作
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))))
// 当前槽指向的节点的key刚好和新增元素的key一样
// 这行判断的代码也在讲解JDK1.7的时候详细讲解过
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
// 如果链表长度等于8，该方法可能将链表转化成红黑树
// 由于节点已经插入单链表而binCount尚未加一，所以TREEIFY_THRESHOLD需要减一
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 在链表上找到了要插入的key
break;
p = e;
}
}
if (e != null) { // existing mapping for key
// key已经存在HashMap中
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 用新值替换旧值
e.value = value;
// 该方法是为LinkedHashMap准备的
afterNodeAccess(e);
// 此处直接返回旧值，因为没有改变HashMap的结构，也不需要检查扩容
return oldValue;
}
}
// 修改了表结构，modCount加一
++modCount;
// 检查是否需要扩容
if (++size > threshold)
resize();
// 该方法是为LinkedHashMap准备的
afterNodeInsertion(evict);
return null;
}
JDK1.8中的HashMap源码可读性不如JDK1.7，其中一个很重要的原因就是变量都是单个字母，根本做不到见名知意，这也提醒我们：命名不规范，同事两行泪。
看完了源码，再从整体上把握一下put方法的逻辑：
- 数组
table是否已经初始化，否的话先初始化（扩容），执行第2步 - 如果当前槽（slot）为空，直接将元素插入到当前槽，执行第8步，不为空时执行第3步
- 判断当前槽指向的key是否和新增元素的key一样，是的话记录该节点，执行第7步，否的话执行第4步
- 判断当前槽指向的节点是不是红黑树的节点，是的话执行红黑树的插入操作，否的话说明是单链表的头节点，执行第5步
- 遍历单链表，查找单链表上是否包含了新增元素的key，是的话记录该节点，跳出循环执行第7步，否的话遍历到单链表末尾，执行尾插入
- 插入成功后判断是否需要将单链表转化成红黑树，需要就转
- 判断新增元素的key是否已经存在，是的话用新值替换旧值，并返回旧值，方法结束。否的话执行第8步
- 维护
modCount - 根据
size和threshold判断是否需要扩容，需要扩容就扩容，不需要就结束方法
根据JDK1.7和JDK1.8的源码对比可以看出，JDK1.8对HashMap做了如下优化：
- 引入了红黑树结构，hash冲突严重时，显著提高查询效率
- 存储元素的内部类由
Entry变成了Node - 重新实现了hash函数
- 扩容时机、扩容方式发生了变化
接着看put方法中使用到的hash方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这个方法等价于：
static final int hash(Object key) {
int h;
if (key == null) {
return 0;
}
// 取key的hash值
h = key.hashCode();
// 取hash值的高16位
int height = h >>> 16;
// 用hash值和hash值的高16位做异或运算（exclusive OR）
return h ^ height;
}
这样做是为了让hash值的高位和低位均参与运算，混合原始哈希值的高位和低位，以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。
接着看put方法中最重要的一个方法resize
final Node<K,V>[] resize() {
// 插入第一个元素时，table为null
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
// 初始化时指定的容量，结合构造方法看，这个值就是tableSizeFor()方法计算后的值，一定是2的n次幂
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"})
// 初始化table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 排除插入第一个元素的情况
// 遍历table
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) {
// 扩容后槽的下标没有变化
// 扩容前处于table[n]，扩容后还处于table[n]
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
// 扩容后下标变为：原来的下标加新容量的一半
// 扩容前处于table[n]，扩容后处于table[n + newCapacity / 2]
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;
}
注意第61行的代码(e.hash & oldCap) == 0就可以判断，当前槽上的链表在扩容前和扩容后，所在的槽（slot）下标是否一致。举个例子：
假如一个key的hash值为1001 1100，转换成十进制就是156，数组长度为1000，转换成十进制就是8。
1001 1100
& 0000 1000
--------------
0000 1000
也就是(e.hash & oldCap) != 0，很容易计算出，扩容前这个key的下标是4（156 % 8 = 4），扩容后下标是12（156 % 16 = 12）即：12 = 4 + 16 / 2，满足n = n + newCapacity / 2，由此可以看出这种计算方式非常巧妙。至于第61行之后的代码就是基本的单链表操作了，只是一个单链表同时具有头指针和尾指针，等到链表被分成高位链表和低位链表后，再一次性转移到新的table。这样就完成了单链表在扩容过程中的转移，使用两条链表的好处就是转移前后的链表不会倒置，更不会因为多线程扩容而导致死循环。
get方法
get方法用于从HashMap中取元素，也是非常常用的方法，具体实现如下：
public V get(Object key) {
Node<K,V> e;
// 实际调用内部getNode方法
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) {
// 这行代码做了三个判断，分别是table不为null、table长度大于0、根据key的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;
}
以上便是get方法执行的逻辑。基本上和JDK1.7中的get方法执行的逻辑差不多，只是多了红黑树的分支。
总结
本篇主要讲解了JDK1.7和JDK1.8两个版本下的HashMap的数据结构、核心方法、扩容机制等，HashMap应用非常广泛，是学习Java集合框架无法避免的类。HashMap是一个非常经典的类，完全可以从HashMap感受到大牛们写类库时的智慧。
HashMap首先结合了数组和单链表，利用了数组的可以根据下标随机访问的优点，同时又利用了链表这种动态数据结构的特性。到JDK1.8时，如果Hash冲突比较严重，会导致链表长度过长，查询效率降低（查询时间复杂度O(n)）。从而引入了红黑树（查询时间复杂度O(logn)），大大提高了查询效率。
以上就是本篇关于HashMap的全部内容。
