集合源码解析：HashMap的底层实现原理(jdk8.0)
源码解析JDK8.0集合：HashMap底层实现原理
一、HashMap的概述
HashMap是Map接口的实现类，键值对存储(基于哈希表的映射：根据指定的键，可以获取对应
的值)，并允许null作为键和值，线程不安全，即方法为非同步方法。这一点jdk7.0 和 jdk8.0没
有区别。
二、HashMap的存储结构
-
jdk7.0中的HashMap采用数组+链表形式进行存储，但是如果一个数组对应的链表长度过大
时，通过key进行查询时效率较低；为了提高效率，jdk8.0中HashMap最大的优化亮点就在
于采用了数组 + 链表 + 红黑树的 存储方式 。
-
jdk8.0的HashMap 底层结构依然是一个数组(默认长度为16)也称为哈希表，同样的数组元素
是一个单向的链表，每一个数组存储的元素代表的是每一个链表的头结点；但是当数组中某
并且一个链表长度>=8，数组的长度不小于 64 时，会将此链表转换为 红黑树的存储方式，
存储结构如下：
三、HashMap内部实现原理机制(源码解析)
-
HashMap的基本元素
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { /* 默认的初始容量为：16 1 << 4 代表将1左移4位：2^4 = 16 */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 //最大容量为2^30 = 1024*1024*1024 = 1073741824 static final int MAXIMUM_CAPACITY = 1 << 30; /* 默认的负载因子 负载因子表示一个散列空间的使用程度。 当向集合容器中添加元素的时候，会判断当前容器的个数： 如果当前容器的个数 > 阈(yu)值：即底层数组长度*负载因子 */ static final float DEFAULT_LOAD_FACTOR = 0.75f; /*新增： 如果数组某一个元素中的链表节点数 >= 8时， 需要转换为 红黑树形式存储 */ static final int TREEIFY_THRESHOLD = 8; /*新增： 如果数值中某一个 元素转换为红黑树存储之后，在之后的操作中 检测到节点数 <6 时，则解散红黑树存储，再 转换为 链表形式 进行存储 */ static final int UNTREEIFY_THRESHOLD = 6; /*新增： 如果数组某一个元素中的链表节点数 >= 8时，需要转换为 红黑树形式存储，但是 同时 需要 还满足此时的数组长度 不能不小 64 ，否则也不会转换为 红黑树形式存储 */ static final int MIN_TREEIFY_CAPACITY = 64; /*改变： jdk8.0中底层数组类型由 Entry 类型改变为 Node 类型 但是 Node 为 Map.Entry接口的实现类 (注意：Entry为Map接口中的内部接口) */ transient Node<K,V>[] table; // Map集合中键值对的 个数 transient int size; // 记录对集合中元素修改的次数 transient int modCount; /* 扩容的临界值(阈值)，或者所能容纳的key-value对的极限。 当size>threshold的时候就会扩容 */ int threshold; // 加载因子 final float loadFactor;jdk8.0中HashMap的实现类中字段部分相对于 jdk7.0做出了部分的改变，没有改变的字段不再详细介绍，以下介绍的为改变或是新增的字段：
(1) TREEIFY_THRESHOLD = 8 和 MIN_TREEIFY_CAPACITY = 64
数组中某一个元素对应的链表形式存储 是否需要转换为红黑树进行存储的依据。
如果链表长度大于等于 8，同时Node[] table数组长度不小于 64，则将此链表转换为
红黑树进行存储 。
(2) UNTREEIFY_THRESHOLD = 6
被转换为红黑树进行存储的 再次 转换为 链表存储的临界值
(3) Node
Node
Node中包含了键和值，详见以下源码：
// 此静态内部类和内部的属性和方法都是包级访问权限 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; } .... ｝存储的具体结构如下：
-
HashMap中的构造方法相比于 jdk7.0中的HashMap 没有大的变动，不再具体讲解
-
HashMap中存储：put方法的实现
public V put(K key, V value) { // 调用 hash方法获取 key对应的哈希码值 return putVal(hash(key), key, value, false, true); }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; // 如果 table 为空，则新建一个 table if ((tab = table) == null || (n = tab.length) == 0) // 调用 resize 方法实现新建table数据 n = (tab = resize()).length; /* 根据 数组长度 和 哈希码值进行 与 运算得到一个存储下标 如果存储位置上，没有元素，则新建 一个 Node 直接存储即可 */ if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); // 如果对应下标位置上，已经有元素 else { Node<K,V> e; K k; // 如果恰巧和第一个节点中的数据冲突，将 e 指向第一个节点 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; /* 如果是采用的红黑树形式存储，则需要利用红黑树的putTreeVal 方法将 键值对进行存储 */ else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // 否则 是 链式存储 else { // 利用循环，遍历链表中的每一个节点，判断 是否存在重复的键 for (int binCount = 0; ; ++binCount) { // 如果到了链表的尾部，还没有发现有相同的key if ((e = p.next) == null) { // 则新建一个新节点插入到链表的尾部 p.next = newNode(hash, key, value, null); //如果链表长度大于TREEIFY_THRESHOLD对应的数值 if (binCount >= TREEIFY_THRESHOLD - 1) // 转换为 红黑树 进行存储 treeifyBin(tab, hash); break; } // 如果发现和某个节点的 key 相同，则结束循环 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; // 目的是：让下一次的循环 操作下一个节点 p = e; } } // 条件成立，则代表在以上操作中找到了重复的key，则新值替换旧值 if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; // 对集合修改的次数加1 // 判断是否需要扩容 if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }解析：put方法实现的原理如下：
(1) 调用 hash方法 获取 key 对应 的 哈希码值
(2) 如果 table 为空，则先新建一个table数组
(3) 如果根据key的哈希码值和table数组长度获取的存储下标位置上没有任何
数据，则直接存储即可
(4) 如果需要存储的table对应下标位置上已有元素，则需要判断是否有冲突key：
a. 先判断数组对应位置上，第一个节点是否存在冲突，冲突直接获取此节点
b. 再判断是否采用的红黑树存储，是-则利用红黑树中的方法存储键值对
c. 采用链式存储，则需要遍历的判断链表中是否有冲突的 key
I. 如果到最后一个节点，还没有发现有冲突的key，则新建一个节点插入到尾部
同时在这个步骤中判断链表是否需要转换为红黑树进行存储，依据为链表长度
是否大于等于8
II. 如果循环过程中，发现有冲突的key，则获取该节点，同时结束循环
d. 如果存在有冲突的 key，则新值替换旧值
应用层解析总结：jdk7.0 和 jdk8.0 要求没有区别
如果自定类型的元素作为HashMap的键时，需要覆盖hashCode方法和equals方法：
(1) 覆盖hashCode方法的原则：
a. 必须保证内容相同的元素返回相同的哈希码值
b. 为了提高效率，尽可能做到内容不同的元素返回不同的哈希码值
(2) equals方法：内容相同的对象返回true。
-
HashMap的读取：get方法的实现
public V get(Object key) { Node<K,V> e; // 调用getNode方法获取和 key相同的 Node 节点 return (e = getNode(hash(key), key)) == null ? null : e.value; }getNode方法的源码：
final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; // 如果table不为空，同时table长度大于0，同时数组对应下标存储内容不为null if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { // 如果 数组对应下标的第一个节点中的key 和 要查找的key相同 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) // 直接返回第一个节点 return first; // 如果第一个节点的key和要查找的key不同，同时后面还有其他节点 if ((e = first.next) != null) { // 如果采用的是红黑树方式进行存储的 if (first instanceof TreeNode) // 通过 红黑树 获取 key 对应的Node return ((TreeNode<K,V>)first).getTreeNode(hash, key); // 不是红黑树，则需要遍历节点，查找和 key相同的节点 do { // 如果查找到和key相同的节点，返回该节点 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } // 如果 table为null，或是不存在该key，则返回null即可 return null; }解析：put方法实现原理如下：
(1) 如果 table不为空，或是对应key对应的存储下标元素不为null
a. 先判断第一个节点 是否和要查找的key映射的节点，相同则直接返回此节点
b. 如果第一个节点 不是要查找的key映射的节点，则需要判断后面的节点
I. 如果为红黑树形式存储，则需要利用 红黑树进行操作
II. 如果为传统链表形式存储，则遍历所有节点，找到则返回对应的Node
(2) 如果table为空，或是key没有映射的结果，则返回null
-
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; // 判断 table长度是否大于 0 if (oldCap > 0) { // 如果 table长度大于最大空间，无法再扩容 if (oldCap >= MAXIMUM_CAPACITY) { // 则扩容的临界值设置为Integer区间的最大值 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) newCap = oldThr; else { 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; // 基于新的容量创建新 Node数组 ---》新的哈希表 @SuppressWarnings({ "rawtypes","unchecked"}) 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; //如果数组对应的下标元素 不为 null if ((e = oldTab[j]) != null) { oldTab[j] = null; // 如果数组此下标对应位置仅有一个Node节点 if (e.next == null) // 存储在新数组 位置上即可 newTab[e.hash & (newCap - 1)] = e; // 如果此位置采用的红黑树形式存储，则将红黑树进行分离 else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); // 如果此位置采用的链式存储了多个Node节点元素 else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; // 循环的获取每一个Node节点的新位置 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方法为HashMap的扩容方法，如果Map中存储的键值对的
个数 > 扩容的临界值(threshold)时，Node[] table 数组就需要扩容。
四、总结
jdk7.0中的HashMap是采用拉链的方法解决存储冲突的问题，如果一个桶(数组元素)中冲突
严重，即链表过长，会导致效率降低，而jdk8.0通过红黑树的形式进行优化，将效率适当的
提高。但是相比链式结构，树型结构的节点比较占空间，所以这是一种以空间换时间的改进
方式。
备注：关于红黑树的相关内容，可以查阅数据结构相关资料，翻看树的章节。