内容摘要：前几天H同学和我聊了下去谷歌的面试经验，令我诧异的是，没想到谷歌也问集合之后，我便觉得需要再整理一波集合相关的了。看文章前可以先看看以下高频考点，如果觉得莫得问题，可以直接跳过该篇文章了，不用浪费时间

前几天H同学和我聊了下去谷歌的懒加面试经验，令我诧异的懒加是，没想到谷歌也问集合之后，懒加我便觉得需要再整理一波集合相关的懒加了。

看文章前可以先看看以下高频考点，懒加如果觉得莫得问题，懒加可以直接跳过该篇文章了，懒加不用浪费时间。懒加

new HashMap() 和 new HashMap(int initialCapacity) ，懒加具体有什么区别?懒加 HashMap中的数据多于多少个时才会进行扩容? HashMap中的链表结构什么时候转成红黑树?一定会转吗? 红黑树结构又什么时候才会转回链表? 说说看HashMap的懒加载?负载因子的作用?

特征解析

为了搞清楚一个概念，这篇文章引入竹篮和鸡蛋的懒加概念，缓存的懒加数据就是鸡蛋，而节点就是懒加竹篮，HashMap底层是懒加一个竹篮数组，每个竹篮是懒加一个链表或者红黑树的结构，每个竹篮也可以放多个鸡蛋，因此其实可以当成二维数组来看待，只是在这里的高防服务器第二维数组是一个链表或者红黑树，至于这个竹篮的结构是链表还是红黑树，就看竹篮内的的鸡蛋个数有多少，并且链表和红黑树之间可以进行转换。

通过散列函数将鸡蛋定位到表中的具体竹篮，以提升查询速度，其底层用于存放数据的数组也叫散列表。所谓散列函数，简单来说就是将一个无限大的集合(在 HashMap 中，key值是一个无限大集合)，经过 hash 运算取模，均匀的分布在一个有限的集合(我们定义的哈希表容量，比如长度 16 的数组)

源码解析

成员变量和常量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认的初始容量，预计所有竹篮累计可以放16个鸡蛋 static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量，所有竹篮最多可以放多少个鸡蛋 static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认加载因子，装逼用，一般都会在应用探讨bb的亿华云计算时候提一嘴 static final int TREEIFY_THRESHOLD = 8;  // 单个竹篮放的鸡蛋个数超过8转红黑树 static final int UNTREEIFY_THRESHOLD = 6; // 单个竹篮放的鸡蛋个数小于6则转链表 static final int MIN_TREEIFY_CAPACITY = 64; // 如果竹篮个数小于64个，会先进行扩容，而不会链表转红黑树 transient Node<K,V>[] table;  // 哈希表数组，存储数据的地方，每个竹篮结构可能为链表或者红黑树，总是2的幂次倍 transient Set<Map.Entry<K,V>> entrySet; // 存放具体元素的集合，可用于遍历Map transient int size; // 总的鸡蛋个数 transient int modCount;  // 插入删除元素，modCount++,用于记录改变次数 int threshold; // 容量阈值，所有竹篮允许缓存鸡蛋的个数，超过这个值需要扩容，默认为0，看看后续是如何变化的，对理解扩容那块很重要 final float loadFactor; // 加载因子，能够权衡时间复杂度和空间复杂度 

笔试or面试需要记住几个死记硬背的点，那就是：hashmap的默认初始容量为16，加载因子是0.75，链表长过8则转红黑树，小于6则转链表，容量低于64则先扩容，源码下载而不会链表转红黑树。

看看构造方法

HashMap有四个构造方法，这里只列出我们常用的两个

第一个是默认构造方法，我们不指定默认所有竹篮累计可以放16个鸡蛋 第二个是指定初始容量，也是我们比较推荐的做法，根据需要设置大小，避免后面resize扩容开销

日常开发中如果知道大小，我们都会用第二种，可以避免resize扩容开销，新手开发经常会直接用第一种，一般我review代码看到都会直接打回改，然后告诉他们为啥，想想看，如果你已经知道这个map容器要装的元素是100个，你还不指定初始容量，那么就会导致在第一次put数据的时候进行扩容，此时第一次扩容因为没有初始容量，计算出的容量阈值为默认大小16，16*加载因子0.75f就是12，之后当你继续put值超过12个的时候又会继续扩容，第二次扩容后容量阈值为24，循环刚刚的过程直到容量阈值大于100，而如果指定了默认大小则第一次扩容就够用了，不用走后面那么多次扩容，可以节省性能;

其次是命名也要注意下，最好是直接用Map结合，比如xxxMap，这是规范。

扩容

我们先回顾下上面的一个成员变量threshold

「int threshold; // 容量阈值，所有竹篮允许放入鸡蛋的个数」

ok了，继续讲扩容，扩容分为多种情况

如果我们使用了无参构造方法，可以看到

其中并未对成员变量threshold容量阈值进行初始化，反调threshold赋值的地方可以看到在put第一个元素的时候会调用resize方法，该方法有做了容量阈值的计算，计算方式为：DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY，也就是默认的加载因子 * 默认容量，即 0.75f * 16，即12

如果指定了初始容量

可以看到初始容量阈值的计算公式是：

这么一坨东西是啥呢，其实就是一个算法，看不懂也莫得关系，毕竟我也看不懂，记住就好，这个算法其实就是返回大于输入参数且最近的2的整数次幂的数，比如设置的初始容量为10，那么这个算法则返回16。

但是，到了这里其实也并没有分配好数组，可以看到resize方法，其实也是在put的时候才会真正进行数组的分配，也就是懒加载了。

二次扩容，最终都会走向resize方法，每次扩容量都会是原先的2倍。

我们可以看看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) {              // 如果竹篮个数大于最大容量，则将容量阈值设置成int的最大值             if (oldCap >= MAXIMUM_CAPACITY) {                  threshold = Integer.MAX_VALUE;                 return oldTab;             }            // 否则新阈值为旧阈值两倍             else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                      oldCap >= DEFAULT_INITIAL_CAPACITY)                 newThr = oldThr << 1;         }         else if (oldThr > 0)              newCap = oldThr;         else {                           // 只有默认无参构造方法才会走到这个分支，阈值为默认算法，容量 * 0.75             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)                     // 竹篮内内的鸡蛋数据重hash，红黑树转链表的地方，内部处理主要是当竹篮内的鸡蛋个数小于等于6时，树结构会还原成链表                     ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                 else {  // preserve order                     // 略：链表元素重hash                 }             }         }     }     return newTab; } 

HashMap扩容可以分为三种：

使用默认构造方法初始化HashMap，从前文可以知道HashMap在一开始初始化的时候thershold容量阈值为0，默认值DEFAULT_INITIAL_CAPACITY也就是16，DEFAULT_LOAD_FACTOR为0.75f，因此在第一次put数据的时候会进行扩容，扩容后的容量阈值threshold为DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR = 12; 指定初始容量的构造方法初始化HashMap，可以看到在初始化的时候便通过tableSizeFor进行计算，也就是返回大于输入参数且最近的2的整数次幂的数; 当HashMap不是第一次扩容的时候，那么每次扩容的容量以及容量阈值threshold为原有的两倍。

hash计算

HashCode是啥其实大家都知道，无非就是用来确定对象在HashMap中的存储地址，目的也很简单，为了快，貌似除了了那方面，其他都是越快越好，比如赚钱。

元素插入

我们先回顾下上面的一个成员变量table

「itransient Node<K,V>[] table; // 哈希表数组，存储数据的地方，每个竹篮结构可能为链表或者红黑树，总是2的幂次倍」

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                 boolean evict) {      Node<K,V>[] tab; Node<K,V> p; int n, i;     // 这里如果发现动态数组为null则会初始化数组。     if ((tab = table) == null || (n = tab.length) == 0)         // 第一次放入值时会在这里初始化数组，并且通过resize方法进行扩容         n = (tab = resize()).length;     // 通过hash发现要放入的鸡蛋的数组位置为null，说明没有hash冲突，则直接把该鸡蛋放在这里即可     if ((p = tab[i = (n - 1) & hash]) == null)         tab[i] = newNode(hash, key, value, null);     else {          // 如果要放入的位置已经有该鸡蛋了         Node<K,V> e; K k;         // 判断竹篮的第一个鸡蛋否和新元素key以及hash值都完全一致，如果是则不用看代码都知道进行覆盖，覆盖的逻辑在后面         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);                     //  判断链表长度是否大于8，这里其实减后为7，判断的是binCount,但是因为插入了一个新节点了，所以其实为8                     if (binCount >= TREEIFY_THRESHOLD - 1)                          // 则将列表转为红黑树，所以记住大于8的时候会转成红黑树                         treeifyBin(tab, hash);                     break;                 }                 // 已经找到了hash值和key一样的，则直接break，不用找了，同样在后面进行覆盖                 if (e.hash == hash &&                     ((k = e.key) == key || (key != null && key.equals(k))))                     break;                 p = e;             }         }         // 覆盖操作在这里，新值和旧值的key完全相同，进行覆盖操作         if (e != null) {               V oldValue = e.value;             if (!onlyIfAbsent || oldValue == null)                 e.value = value;             // 访问后回调             afterNodeAccess(e);             return oldValue;         }     }     ++modCount;     // 当map中所有的鸡蛋个数大于容量阈值时则进行扩容，二次扩容如上面所说，也就是两倍     if (++size > threshold)         resize();     afterNodeInsertion(evict);     return null; }  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                 boolean evict) {      Node<K,V>[] tab; Node<K,V> p; int n, i;     // 这里如果发现动态数组为null则会初始化数组。     if ((tab = table) == null || (n = tab.length) == 0)         // 第一次放入值时会在这里初始化数组，并且通过resize方法进行扩容         n = (tab = resize()).length;     // 通过hash发现要放入的鸡蛋的数组位置为null，说明没有hash冲突，则直接把该鸡蛋放在这里即可     if ((p = tab[i = (n - 1) & hash]) == null)         tab[i] = newNode(hash, key, value, null);     else {          // 如果要放入的位置已经有该鸡蛋了         Node<K,V> e; K k;         // 判断竹篮的第一个鸡蛋否和新元素key以及hash值都完全一致，如果是则不用看代码都知道进行覆盖，覆盖的逻辑在后面         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);                     //  判断链表长度是否大于8，这里其实减后为7，判断的是binCount,但是因为插入了一个新节点了，所以其实为8                     if (binCount >= TREEIFY_THRESHOLD - 1)                          // 则将列表转为红黑树，所以记住大于8的时候会转成红黑树                         treeifyBin(tab, hash);                     break;                 }                 // 已经找到了hash值和key一样的，则直接break，不用找了，同样在后面进行覆盖                 if (e.hash == hash &&                     ((k = e.key) == key || (key != null && key.equals(k))))                     break;                 p = e;             }         }         // 覆盖操作在这里，新值和旧值的key完全相同，进行覆盖操作         if (e != null) {               V oldValue = e.value;             if (!onlyIfAbsent || oldValue == null)                 e.value = value;             // 访问后回调             afterNodeAccess(e);             return oldValue;         }     }     ++modCount;     // 当map中所有的鸡蛋个数大于容量阈值时则进行扩容，二次扩容如上面所说，也就是两倍     if (++size > threshold)         resize();     afterNodeInsertion(evict);     return null; }  final void treeifyBin(Node<K,V>[] tab, int hash) {      int n, index; Node<K,V> e;     // 当tab为空或者竹篮个数小于64个，会先进行扩容，而不会链表转红黑树     if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)         resize();     else if ((e = tab[index = (n - 1) & hash]) != null) {          // 真正进行转换的地方         TreeNode<K,V> hd = null, tl = null;         do {              TreeNode<K,V> p = replacementTreeNode(e, null);             if (tl == null)                 hd = p;             else {                  p.prev = tl;                 tl.next = p;             }             tl = p;         } while ((e = e.next) != null);         if ((tab[index] = hd) != null)             hd.treeify(tab);     } } 

put总体流程汇总如下：

罗列几个该注意的点，分别是：

HashMap中缓存数据的数组table，我们可以看到初始化的时候默认是null，是在第一次put数据的时候才进行初始化的，这也是所谓的懒加载，记住了，不要每次提HashMap的懒加载机制都二脸懵逼了。 HashMap中单个竹篮存放的鸡蛋个数大于8，并且当竹篮个数大于64个的时候则将列表转为红黑树，否则进行扩容。 每次put数据时当map中存放的所有鸡蛋个数大于容量阈值时则进行扩容，并且是先put数据，再扩容。

元素查询

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) {         // 如果计算hash值和第一个节点的key值相同，直接返回         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 {                 //如果hash值相同，key不同，则遍历链表找到相同的key，返回                 if (e.hash == hash &&                     ((k = e.key) == key || (key != null && key.equals(k))))                     return e;             } while ((e = e.next) != null);         }     }     return null; } 

查找这里，总结下来流程便是：

根据hash值从竹篮数组内找到竹篮，判断头节点key值与当前key相同，直接返回 如果该竹篮为TreeNode节点，以红黑树方式查找 如果不是则循环遍历链表，直到查到对应的key相同

元素删除

final Node<K,V> removeNode(int hash, Object key, Object value,                                boolean matchValue, boolean movable) {          Node<K,V>[] tab; Node<K,V> p; int n, index;         if ((tab = table) != null && (n = tab.length) > 0 &&             (p = tab[index = (n - 1) & hash]) != null) {              Node<K,V> node = null, e; K k; V v;             if (p.hash == hash &&                 ((k = p.key) == key || (key != null && key.equals(k))))                 node = p;             else if ((e = p.next) != null) {                 //红黑树的查找方式                 if (p instanceof TreeNode)                     node = ((TreeNode<K,V>)p).getTreeNode(hash, key);                 else {                     //链表遍历查找方式                     do {                          if (e.hash == hash &&                             ((k = e.key) == key ||                              (key != null && key.equals(k)))) {                              node = e;                             break;                         }                         p = e;                     } while ((e = e.next) != null);                 }             }            //删除node             if (node != null && (!matchValue || (v = node.value) == value ||                                  (value != null && value.equals(v)))) {                 //如果node为红黑树结点，采用红黑树删除方式                 if (node instanceof TreeNode)                     ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);                // 如果是链表并且node为头结点，当前数组下标元素直接替换为next                 else if (node == p)                     tab[index] = node.next;                 else                    //链表非头元素删除方式                     p.next = node.next;                 ++modCount;                 --size;                 afterNodeRemoval(node);                 return node;             }         }         return null;     } 

删除操作很简单，先根据hash找到对应鸡蛋，然后根据不同类型的节点进行删除，没什么注意的点，如果有，那就是如果是链表表头的话，则需要将下一个节点赋值为表头。

本文转载自微信公众号「稀饭下雪」，可以通过以下二维码关注。转载本文请联系稀饭下雪公众号。