前几天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找到对应鸡蛋，然后根据不同类型的节点进行删除，没什么注意的点，如果有，那就是如果是链表表头的话，则需要将下一个节点赋值为表头。
本文转载自微信公众号「稀饭下雪」，可以通过以下二维码关注。转载本文请联系稀饭下雪公众号。
