这篇文章主要介绍“HashMap的底层实现原理”，在日常操作中，相信很多人在HashMap的底层实现原理问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”HashMap的底层实现原理”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！
我们都知道HashMap是数组+链表组成的，bucket数组是HashMap的主体，而链表是为了解决哈希冲突而存在的，但是很多人不知道其实HashMap是包含树结构的，但是得有一点 注意事项，什么时候会出现红黑树这种红树结构的呢？我们就得看源码了，源码解释说默认链表长度大于8的时候会转换为树。我们看看源码说的
结构
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; }}复制代码接下来就是树结构了
TreeNode 是红黑树的数据结构。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // red-black tree links TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red; TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } final TreeNode<K,V> root() { for (TreeNode<K,V> r = this, p;;) { if ((p = r.parent) == null) return r; r = p; } }复制代码我们在看一下类的定义
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {复制代码继承了抽象的map，实现了Map接口，并且进行了序列化。
在类里还有基础的变量
变量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16static final int MAXIMUM_CAPACITY = 1 << 30; static final float DEFAULT_LOAD_FACTOR = 0.75f;static final int TREEIFY_THRESHOLD = 8;static final int UNTREEIFY_THRESHOLD = 6;static final int MIN_TREEIFY_CAPACITY = 64;transient Node<K,V>[] table;transient Set<Map.Entry<K,V>> entrySet;transient int size;transient int modCount;// (The javadoc description is true upon serialization.// Additionally, if the table array has not been allocated, this// field holds the initial array capacity, or zero signifying// DEFAULT_INITIAL_CAPACITY.)int threshold;final float loadFactor;复制代码我们再看看构造方法
构造方法
public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR);}public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}public HashMap(int initialCapacity, float loadFactor) { // 初始容量不能小于0，否则报错 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); // 初始容量不能大于最大值，否则为最大值 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; //负载因子不能小于或等于0，不能为非数字 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // 初始化负载因子 this.loadFactor = loadFactor; // 初始化threshold大小 this.threshold = tableSizeFor(initialCapacity);}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;}复制代码在这源码中，loadFactor负载因子是一个非常重要的参数，因为他能够反映HashMap桶数组的使用情况， 这样的话，HashMap的时间复杂度就会出现不同的改变。
当这个负载因子属于低负载因子的时候，HashMap所能够容纳的键值对数量就是偏少的，扩容后，重新将键值对 存储在桶数组中，键与键之间产生的碰撞会下降，链表的长度也会随之变短。
但是如果增加负载因子当这个负载因子大于1的时候，HashMap所能够容纳的键值对就会变多，这样碰撞就会增加， 这样的话链表的长度也会增加，一般情况下负载因子我们都不会去修改。都是默认的0.75。加q群：479499375，可获取一份Java进阶学习资料包，有（Java工程化、分布式架构、高并发、高性能、深入浅出、微服务架构、Spring、MyBatis、Netty、源码分析、JVM原理解析等...这些成为架构师必备的内容）以及Java进阶学习路线图。
扩容机制
resize()这个方法就是重新计算容量的一个方法，我们看看源码：
final Node<K,V>[] resize() { //引用扩容前的Entry数组 Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { // 扩容前的数组大小如果已经达到最大(2^30)了 //在这里去判断是否达到最大的大小 if (oldCap >= MAXIMUM_CAPACITY) { //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了 threshold = Integer.MAX_VALUE; return oldTab; } // 如果扩容后小于最大值 而且 旧数组桶大于初始容量16， 阈值左移1(扩大2倍) else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } // 如果数组桶容量<=0 且 旧阈值 >0 else if (oldThr > 0) // initial capacity was placed in threshold //新的容量就等于旧的阀值 newCap = oldThr; else { // zero initial threshold signifies using defaults // 如果数组桶容量<=0 且 旧阈值 <=0 // 新容量=默认容量 // 新阈值= 负载因子*默认容量 newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } // 如果新阈值为0 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; // 如果旧数组桶不是空，则遍历桶数组，并将键值对映射到新的桶数组中 //在这里还有一点诡异的，1.7是不存在后边红黑树的，但是1.8就是有红黑树 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 // 如果不是红黑树，那也就是说他链表长度没有超过8，那么还是链表， //那么还是会按照链表处理 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这个方法之后，元素的位置要么就是在原来的位置，要么就是在原来的位置移动2次幂的位置上。 源码上的注释也是可以翻译出来的
final Node<K,V>[] resize() .....复制代码所以说他的扩容其实很有意思，就有了三种不同的扩容方式了，
在HashMap刚初始化的时候，使用默认的构造初始化，会返回一个空的table，并且 thershold为0，因此第一次扩容的时候默认值就会是16. 同时再去计算thershold = DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY = 16*0.75 = 12.
如果说指定初始容量的初始HashMap的时候，那么这时候计算这个threshold的时候就变成了 threshold = DEFAULT_LOAD_FACTOR * threshold(当前的容量)
到此，关于“HashMap的底层实现原理”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程网网站，小编会继续努力为大家带来更多实用的文章！
