个人文档站点：小熊学Java

1、底层结构

相信大家都已经听过很多了，这里就不多阐述了，至于什么时候是数组，什么时候会变成链表，后续会讲解，别急！

2、树化与退化

1、为什么要用红黑树，为何一上来不树化，树化阈值为何是 8？

1. 红黑树用来避免 DoS 攻击，防止链表超长时性能下降，树化应当是偶然情况

2. hash 表的查找，更新的时间复杂度是 O(1)，而红黑树的查找，更新的时间复杂度是 O(log_2n)，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表。

3. hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，选择 8 就是为了让树化几率足够小

2、何时会树化？

• 链表长度超过树化阈值；

• 数组容量 >= 64

 static final int TREEIFY_THRESHOLD = 8;/*** 当桶数组容量小于该值时，优先进行扩容，而不是树化*/static final int MIN_TREEIFY_CAPACITY = 64;static final class TreeNode extends LinkedHashMap.Entry {TreeNode parent;  // red-black tree linksTreeNode left;TreeNode right;TreeNode prev;    // needed to unlink next upon deletionboolean red;TreeNode(int hash, K key, V val, Node next) {super(hash, key, val, next);}}/*** 将普通节点链表转换成树形节点链表*/final void treeifyBin(Node[] tab, int hash) {int n, index; Node e;// 桶数组容量小于 MIN_TREEIFY_CAPACITY，优先进行扩容而不是树化if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();else if ((e = tab[index = (n - 1) & hash]) != null) {// hd 为头节点（head），tl 为尾节点（tail）TreeNode hd = null, tl = null;do {// 将普通节点替换成树形节点TreeNode 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);}}TreeNode replacementTreeNode(Node p, Node next) {return new TreeNode<>(p.hash, p.key, p.value, next);}

3、何时会退化树？

1. 在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表

2. remove 树节点时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表

退化的源码：

 final Node untreeify(HashMap map) {Node hd = null, tl = null;for (Node q = this; q != null; q = q.next) {Node p = map.replacementNode(q, null);if (tl == null)hd = p;elsetl.next = p;tl = p;}return hd;}

• 在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表

 static final int UNTREEIFY_THRESHOLD = 6;final void split(HashMap map, Node[] tab, int index, int bit) {TreeNode b = this;// Relink into lo and hi lists, preserving orderTreeNode loHead = null, loTail = null;TreeNode hiHead = null, hiTail = null;int lc = 0, hc = 0;// 遍历计算树节点for (TreeNode e = b, next; e != null; e = next) {next = (TreeNode)e.next;e.next = null;if ((e.hash & bit) == 0) {if ((e.prev = loTail) == null)loHead = e;elseloTail.next = e;loTail = e;++lc;}else {if ((e.prev = hiTail) == null)hiHead = e;elsehiTail.next = e;hiTail = e;++hc;}}if (loHead != null) {//小于树节点6，则链化if (lc <= UNTREEIFY_THRESHOLD)tab[index] = loHead.untreeify(map);else {tab[index] = loHead;if (hiHead != null) // (else is already treeified)loHead.treeify(tab);}}if (hiHead != null) {//小于树节点6，则链化if (hc <= UNTREEIFY_THRESHOLD)tab[index + bit] = hiHead.untreeify(map);else {tab[index + bit] = hiHead;if (loHead != null)hiHead.treeify(tab);}}}

• 移除节点时

 final void removeTreeNode(HashMap map, Node[] tab,boolean movable) {int n;if (tab == null || (n = tab.length) == 0)return;int index = (n - 1) & hash;TreeNode first = (TreeNode)tab[index], root = first, rl;TreeNode succ = (TreeNode)next, pred = prev;if (pred == null)tab[index] = first = succ;elsepred.next = succ;if (succ != null)succ.prev = pred;if (first == null)return;if (root.parent != null)root = root.root();// 若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表if (root == null|| (movable&& (root.right == null|| (rl = root.left) == null|| rl.left == null))) {tab[index] = first.untreeify(map);  // too smallreturn;}......}

3、索引是如何计算的

1、索引计算方法

先看源码

 static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//h >>> 16 表示取出h的高16位，具体计算这里就不讲解了}

• 首先，如果对象我null，则返回0，否则计算对象的 hashCode()

• 再进行调用 HashMap 的 hash() 方法进行二次哈希

  • 二次 hash() 是为了综合高位数据，让哈希分布更为均匀

• 最后 & (capacity – 1) 得到索引，这里源码并没有看到

关于这里(h = key.hashCode()) ^ (h >>> 16)不懂的可以参考这篇讲解：https://blog.csdn.net/qq_42034205/article/details/90384772

2、数组容量为何是 2 的 n 次幂

1. 计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模

2. 扩容时重新计算索引效率更高：hash & == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap

注意

• 二次 hash 是为了配合 容量是 2 的 n 次幂 这一设计前提，如果 hash 表的容量不是 2 的 n 次幂，则不必二次 hash

• 容量是 2 的 n 次幂 这一设计计算索引效率更好，但 hash 的分散性就不好，需要二次 hash 来作为补偿，没有采用这一设计的典型例子是 HashTable

下面代码演示：容量是 2 的 n 次幂的设计来讲，二次 hash 非常重要

 public class Utils {/*** 交换元素* @param array* @param i* @param j*/public static void swap(int[] array, int i, int j) {int t = array[i];array[i] = array[j];array[j] = t;}public static void shuffle(int[] array) {Random rnd = new Random();int size = array.length;for (int i = size; i > 1; i--) {swap(array, i - 1, rnd.nextInt(i));}}/*** 随机数组 演示 如果 hashCode 足够随机，容量是否是 2 的 n 次幂影响不大* @param n* @return*/public static int[] randomArray(int n) {int lastVal = 1;Random r = new Random();int[] array = new int[n];for (int i = 0; i < n; i++) {int v = lastVal + Math.max(r.nextInt(10), 1);array[i] = v;lastVal = v;}shuffle(array);return array;}/*** 如果 hashCode 偶数的多，容量是 2 的 n 次幂会导致分布不均匀* @param n* @return*/public static int[] evenArray(int n) {int[] array = new int[n];for (int i = 0; i < n; i++) {array[i] = i * 2;}return array;}/*** 如果 hashCode 低位一样的多，容量是 2 的 n 次幂会导致分布不均匀* @param n* @return*/public static int[] lowSameArray(int n) {int[] array = new int[n];Random r = new Random();for (int i = 0; i < n; i++) {array[i] = r.nextInt() & 0x7FFF0002;}return array;}public static void main(String[] args) {System.out.println(Arrays.toString(randomArray(10)));System.out.println(Arrays.toString(lowSameArray(10)));System.out.println(Arrays.toString(evenArray(10)));}}//[30, 53, 12, 41, 24, 23, 17, 9, 45, 35]//[334561280, 277741568, 2014380034, 388300800, 938082306, 2136473600, 1072037890, 1187053570, 320667648, 700907520]//[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

4、put 与扩容

先看下面流程

1. HashMap 是懒惰创建数组的，首次使用才创建数组

2. 计算索引（桶下标）

3. 如果桶下标还没人占用，创建 Node 占位返回

4. 如果桶下标已经有人占用

   1. 已经是 TreeNode 走红黑树的添加或更新逻辑

   2. 是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑

5. 返回前检查容量是否超过阈值，一旦超过进行扩容

 public V put(K key, V value) {return putVal(hash(key), key, value, false, true);}final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node[] tab; Node p; int n, i;// 初始化桶数组 table，table 被延迟到插入新数据时再进行初始化if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;// 如果桶中不包含键值对节点引用，则将新键值对节点的引用存入桶中即可if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {Node e; K k;// 如果键的值以及节点 hash 等于链表中的第一个键值对节点时，则将 e 指向该键值对if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;// 如果桶中的引用类型为 TreeNode，则调用红黑树的插入方法else if (p instanceof TreeNode)  e = ((TreeNode)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 1sttreeifyBin(tab, hash);break;}// 条件为 true，表示当前链表包含要插入的键值对，终止遍历if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}// 判断要插入的键值对是否存在 HashMap 中if (e != null) { // existing mapping for keyV oldValue = e.value;// onlyIfAbsent 表示是否仅在 oldValue 为 null 的情况下更新键值对的值if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;// 键值对数量超过阈值时，则进行扩容if (++size > threshold)resize();afterNodeInsertion(evict);return null;}

如何扩容的呢？

 final Node[] resize() {Node[] oldTab = table;int oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;int newCap, newThr = 0;//如果table不为空if (oldCap > 0) {//table的长度大于最大容量，则不再记性扩容，返回原tableif (oldCap >= MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return oldTab;}// 按旧容量和阈值的2倍 计算新容量和阈值的大小else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)newThr = oldThr << 1; // double threshold}//threshold > 0，且桶数组未被初始化else if (oldThr > 0) // initial capacity was placed in threshold// this.threshold = tableSizeFor(initialCapacity);//将initialCapacity暂存newCap = oldThr;else {               // zero initial threshold signifies using defaults//  调用无参构造方法时，桶数组容量为默认容量， 阈值为默认容量与默认负载因子乘积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[] newTab = (Node[])new Node[newCap];table = newTab;if (oldTab != null) {//如果旧桶数组不为空，则遍历到新桶数组中for (int j = 0; j < oldCap; ++j) {Node 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)e).split(this, newTab, j, oldCap);else { // preserve orderNode loHead = null, loTail = null;Node hiHead = null, hiTail = null;Node next;// 遍历链表，并将链表节点按原顺序进行分组do {next = e.next;if ((e.hash & oldCap) == 0) {if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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;}

1. 计算新桶数组的容量 newCap 和新阈值 newThr

2. 根据计算出的 newCap 创建新的桶数组，桶数组 table 也是在这里进行初始化的

3. 将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型，则需要拆分红黑树。如果是普通节点，则节点按原顺序进行分组。

加载因子为何默认是 0.75f？

1. 在空间占用与查询时间之间取得较好的权衡

2. 大于这个值，空间节省了，但链表就会比较长影响性能

3. 小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多

5、并发问题

扩容死链（1.7 会存在）

1.7 源码如下：

 void transfer(Entry[] newTable, boolean rehash) {int newCapacity = newTable.length;for (Entry e : table) {while(null != e) {Entry next = e.next;if (rehash) {e.hash = null == e.key ? 0 : hash(e.key);}int i = indexFor(e.hash, newCapacity);e.next = newTable[i];newTable[i] = e;e = next;}}}

• e 和 next 都是局部变量，用来指向当前节点和下一个节点

• 线程1（绿色）的临时变量 e 和 next 刚引用了这俩节点，还未来得及移动节点，发生了线程切换，由线程2（蓝色）完成扩容和迁移

• 线程2 扩容完成，由于头插法，链表顺序颠倒。但线程1 的临时变量 e 和 next 还引用了这俩节点，还要再来一遍迁移

• 第一次循环

  • 循环接着线程切换前运行，注意此时 e 指向的是节点 a，next 指向的是节点 b

  • e 头插 a 节点，注意图中画了两份 a 节点，但事实上只有一个（为了不让箭头特别乱画了两份）

  • 当循环结束是 e 会指向 next 也就是 b 节点

• 第二次循环

  • next 指向了节点 a

  • e 头插节点 b

  • 当循环结束时，e 指向 next 也就是节点 a

• 第三次循环

  • next 指向了 null

  • e 头插节点 a，a 的 next 指向了 b（之前 a.next 一直是 null），b 的 next 指向 a，死链已成

  • 当循环结束时，e 指向 next 也就是 null，因此第四次循环时会正常退出

数据错乱（1.7，1.8 都会存在）

 public class HashMapMissData {public static void main(String[] args) throws InterruptedException {HashMap map = new HashMap<>();Thread t1 = new Thread(() -> {map.put("a", new Object()); // 97  => 1}, "t1");Thread t2 = new Thread(() -> {map.put("1", new Object()); // 49 => 1}, "t2");t1.start();t2.start();t1.join();t2.join();System.out.println(map);}}

操作：多线程情况下，t1线程在put的时候，此时运行t2的线程，完成put操作，t1 put操作就会丢失数据

6、key 的设计

key 的设计要求

1. HashMap 的 key 可以为 null，但 Map 的其他实现则不然

2. 作为 key 的对象，必须实现 hashCode 和 equals，并且 key 的内容不能修改（不可变）

3. key 的 hashCode 应该有良好的散列性

如果 key 可变，例如修改了 age 会导致再次查询时查询不到

 public class HashMapMutableKey {public static void main(String[] args) {HashMap map = new HashMap<>();Student stu = new Student("张三", 18);map.put(stu, new Object());System.out.println(map.get(stu));stu.age = 19;System.out.println(map.get(stu));}static class Student {String name;int age;public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}}}//java.lang.Object@63961c42//null

String 对象的 hashCode() 设计

• 目标是达到较为均匀的散列效果，每个字符串的 hashCode 足够独特

• 字符串中的每个字符都可以表现为一个数字，称为 Si，其中 i 的范围是 0 ~ n - 1

• 散列公式为： 

  

• 31 代入公式有较好的散列特性，并且 31 * h 可以被优化为

  

好了，本文就到这里了！如果觉得内容不错的话，希望大家可以帮忙点赞转发一波，这是对我最大的鼓励，感谢🙏🏻

资料获取👇 最后面就是领取暗号，公众号回复即可！