文章目錄

• • 構(gòu)造方法
  • tableSizeFor()計(jì)算容量
• 源碼分析
• • 1. hashmap的數(shù)據(jù)結(jié)構(gòu)
  • 1. hash()
  • 2. resize()
  • 3. putVal( )

構(gòu)造方法

HashMap有四個(gè)構(gòu)造方法，分別可以指定容量、加載因子，或者直接將map作為參數(shù)傳入

/*** 無參構(gòu)造方法HashMap()構(gòu)造一個(gè)空的HashMap，初始容量為16，負(fù)載因子為0.75* Constructs an empty <tt>HashMap</tt> with the default initial capacity* (16) and the default load factor (0.75).*/public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}/*** Constructs an empty <tt>HashMap</tt> with the specified initial* capacity and the default load factor (0.75).*/public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);}/*** Constructs an empty <tt>HashMap</tt> with the specified initial* capacity and load factor.*/public HashMap(int initialCapacity, float loadFactor) {//如果初始容量小于0，拋出異常if (initialCapacity < 0)throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);//如果初始容量超過1 << 30（即2的30次方） if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;//如果負(fù)載因子小于等于0，或者不是個(gè)數(shù)字，拋出異常if (loadFactor <= 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: " +loadFactor);this.loadFactor = loadFactor;//關(guān)鍵方法this.threshold = tableSizeFor(initialCapacity);}/*** Constructs a new <tt>HashMap</tt> with the same mappings as the* specified <tt>Map</tt>. The <tt>HashMap</tt> is created with* default load factor (0.75) and an initial capacity sufficient to* hold the mappings in the specified <tt>Map</tt>.** @param m the map whose mappings are to be placed in this map* @throws NullPointerException if the specified map is null*/public HashMap(Map<? extends K, ? extends V> m) {this.loadFactor = DEFAULT_LOAD_FACTOR;putMapEntries(m, false);}/*** 直接看putMapEntries()方法，* 將m的所有元素存入本HashMap實(shí)例中，putAll()調(diào)用的其實(shí)就是這個(gè)方法*/final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {//得到 m中元素的個(gè)數(shù)int s = m.size();//當(dāng) m 中有元素時(shí)才進(jìn)行拷貝if (s > 0) {//如果table未初始化，則先初始化一些變量。（table初始化是在put時(shí)）if (table == null) { // pre-size// 根據(jù)待插入的map 的 size 計(jì)算要?jiǎng)?chuàng)建的　HashMap 的容量。float ft = ((float)s / loadFactor) + 1.0F;int t = ((ft < (float)MAXIMUM_CAPACITY) ?(int)ft : MAXIMUM_CAPACITY);// 把要?jiǎng)?chuàng)建的　HashMap 的容量存在　threshold　中if (t > threshold)threshold = tableSizeFor(t);}// 如果table初始化過，因?yàn)閯e的函數(shù)也會(huì)調(diào)用它，所以有可能HashMap已經(jīng)被初始化過了。// 若　size 大于　threshold，則先進(jìn)行resize()擴(kuò)容else if (s > threshold)resize();//然后就開始遍歷待插入的 map ，將每一個(gè) <Key ,Value> 插入到本HashMap實(shí)例。for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {K key = e.getKey();V value = e.getValue();// put(K,V)也是調(diào)用　putVal　函數(shù)進(jìn)行元素的插入putVal(hash(key), key, value, false, evict);}}}

注意這里通過tableSizeFor方法計(jì)算了threshold。
這個(gè)threshold = capacity * load factor ，當(dāng)HashMap的size到了threshold時(shí)，就要進(jìn)行resize，也就是擴(kuò)容。

tableSizeFor()計(jì)算容量

tableSizeFor()的功能是返回下一擴(kuò)容后的容量值，即一個(gè)比給定整數(shù)大且最接近的2的冪次方整數(shù)，如給定10，返回2的4次方16。HashMap要求容量必須是2的冪。

/*** Returns a power of two size for the given target capacity.*/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;}

在說明這個(gè)方法前，先說一下右移的含義，運(yùn)算規(guī)則：
>> ：按二進(jìn)制形式把所有的數(shù)字向右移動(dòng)對(duì)應(yīng)位數(shù)，低位移出（舍棄），高位的空位補(bǔ)符號(hào)位，即正數(shù)補(bǔ)零，負(fù)數(shù)補(bǔ)1。符號(hào)位不變。
>>>：按二進(jìn)制形式把所有的數(shù)字向右移動(dòng)對(duì)應(yīng)位數(shù)，低位移出（舍棄），高位的空位補(bǔ)零。對(duì)于正數(shù)來說和帶符號(hào)右移相同，對(duì)于負(fù)數(shù)來說不同。
-1在32位二進(jìn)制中表示為：
11111111 11111111 11111111 11111111
-1>>1：按位右移，符號(hào)位不變，仍舊得到
11111111 11111111 11111111 11111111
因此值仍為-1
而-1>>>1的結(jié)果為 01111111 11111111 11111111 11111111

? ? ? ?接著說tableSizeFor()。首先，int n = cap -1是為了防止cap已經(jīng)是2的冪時(shí)，執(zhí)行完后面的幾條無符號(hào)右移操作之后，返回的capacity是這個(gè)cap的2倍。

? ? ? ?如果n=0（經(jīng)過了cap-1之后），則經(jīng)過后面的幾次無符號(hào)右移依然是0，最后返回的capacity是1（最后有個(gè)n+1的操作）。
? ? ? ?以16位為例，假設(shè)開始時(shí) n 為 0000 1xxx xxxx xxxx （x代表不關(guān)心0還是1）

• 第一次右移 n |= n >>> 1;

? ? ? ?由于n不等于0，則n的二進(jìn)制表示中總會(huì)有一bit為1，這時(shí)考慮最高位的1。通過無符號(hào)右移1位，則將最高位的1右移了1位，再做或操作，使得n的二進(jìn)制表示中與最高位的1緊鄰的右邊一位也為1，如0000 11xx xxxx xxxx 。

• 第二次右移 n |= n >>> 2;

? ? ? ?注意，這個(gè)n已經(jīng)經(jīng)過了n |= n >>> 1; 操作。此時(shí)n為0000 11xx xxxx xxxx ，則n無符號(hào)右移兩位，會(huì)將最高位兩個(gè)連續(xù)的1右移兩位，然后再與原來的n做或操作，這樣n的二進(jìn)制表示的高位中會(huì)有4個(gè)連續(xù)的1。如0000 1111 xxxx xxxx 。

• 第三次右移 n |= n >>> 4;

? ? ? ?這次把已經(jīng)有的高位中的連續(xù)的4個(gè)1，右移4位，再做或操作，這樣n的二進(jìn)制表示的高位中會(huì)有8個(gè)連續(xù)的1。如0000 1111 1111 xxxx 。

? ? ? ?這時(shí)基本清晰了，容量最大也就是32位的正數(shù)，所以最后一次 n |= n >>> 16; 可以保證最高位后面的全部置為1。當(dāng)然如果是32個(gè)1的話，此時(shí)超出了MAXIMUM_CAPACITY ，所以取值到MAXIMUM_CAPACITY 。
下面舉個(gè)實(shí)際的例子：

? ? ? ?注意，得到的這個(gè)capacity直接被賦值給了threshold。 開始認(rèn)為應(yīng)該這么寫：this.threshold = tableSizeFor(initialCapacity) * this.loadFactor; 因?yàn)檫@樣子才符合threshold的定義：threshold = capacity * load factor 。但是請(qǐng)注意，在構(gòu)造方法中，并沒有對(duì)table這個(gè)成員變量進(jìn)行初始化，table的初始化被推遲到了put方法中，在put方法中會(huì)對(duì)threshold重新計(jì)算 。

重要的有resize()，hash(key)，putVal( )方法，下面重點(diǎn)講解。

源碼分析

1. hashmap的數(shù)據(jù)結(jié)構(gòu)

? ? ? ?其實(shí)就是數(shù)組加鏈表，java8引入紅黑樹來提高查詢效率。
? ? ? ?HashMap使用鏈表法處理哈希值沖突的情況（相同hash值），當(dāng)鏈表長(zhǎng)度大于TREEIFY_THRESHOLD（默認(rèn)為8）時(shí)，將鏈表轉(zhuǎn)換為紅黑樹，當(dāng)然小于UNTREEIFY_THRESHOLD（默認(rèn)為6）時(shí)，又會(huì)轉(zhuǎn)回鏈表以達(dá)到性能均衡。 我們看一張HashMap的數(shù)據(jù)結(jié)構(gòu)（數(shù)組+鏈表+紅黑樹 ）就更能理解table(每個(gè)table其實(shí)就是Node<K,V>)了：

幾個(gè)重要的成員變量：

/*** 數(shù)組的默認(rèn)初始長(zhǎng)度，java規(guī)定hashMap的數(shù)組長(zhǎng)度必須是2的次方* 擴(kuò)展長(zhǎng)度時(shí)也是當(dāng)前長(zhǎng)度 << 1。*/ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16// 數(shù)組的最大長(zhǎng)度 static final int MAXIMUM_CAPACITY = 1 << 30;// 默認(rèn)負(fù)載因子，當(dāng)元素個(gè)數(shù)超過這個(gè)比例則會(huì)執(zhí)行數(shù)組擴(kuò)充操作。 static final float DEFAULT_LOAD_FACTOR = 0.75f;// 樹形化閾值，當(dāng)鏈表節(jié)點(diǎn)個(gè)大于等于TREEIFY_THRESHOLD - 1時(shí)， // 會(huì)將該鏈表?yè)Q成紅黑樹。 static final int TREEIFY_THRESHOLD = 8;// 解除樹形化閾值，當(dāng)鏈表節(jié)點(diǎn)小于等于這個(gè)值時(shí)，會(huì)將紅黑樹轉(zhuǎn)換成普通的鏈表。 static final int UNTREEIFY_THRESHOLD = 6;// 最小樹形化的容量，即：當(dāng)內(nèi)部數(shù)組長(zhǎng)度小于64時(shí)，不會(huì)將鏈表轉(zhuǎn)化成紅黑樹，而是優(yōu)先擴(kuò)充數(shù)組。 static final int MIN_TREEIFY_CAPACITY = 64;// 這個(gè)就是hashMap的內(nèi)部數(shù)組了，而Node則是鏈表節(jié)點(diǎn)對(duì)象。 transient Node<K,V>[] table;// 下面三個(gè)容器類成員，作用相同，實(shí)際類型為HashMap的內(nèi)部類KeySet、Values、EntrySet。 // 他們的作用并不是緩存所有的key或者所有的value，內(nèi)部并沒有持有任何元素。 // 而是通過他們內(nèi)部定義的方法，從三個(gè)角度（視圖）操作HashMap，更加方便的迭代。 // 關(guān)注點(diǎn)分別是鍵，值，映射。 transient Set<K> keySet; // AbstractMap的成員 transient Collection<V> values; // AbstractMap的成員 transient Set<Map.Entry<K,V>> entrySet;// 元素個(gè)數(shù)，注意和內(nèi)部數(shù)組長(zhǎng)度區(qū)分開來。 transient int size;// 是容器結(jié)構(gòu)的修改次數(shù)，fail-fast機(jī)制。 transient int modCount;// 閾值，超過這個(gè)值時(shí)擴(kuò)充數(shù)組。 threshold = capacity * load factor，具體看上面的靜態(tài)常量。 int threshold;// 裝在因子，具體看上面的靜態(tài)常量。 final float loadFactor;

1. hash()

/*** key 的 hash值的計(jì)算是通過hashCode()的高16位異或低16位實(shí)現(xiàn)的：(h = k.hashCode()) ^ (h >>> 16)* 主要是從速度、功效、質(zhì)量來考慮的，這么做可以在數(shù)組table的length比較小的時(shí)候* 也能保證考慮到高低Bit都參與到Hash的計(jì)算中，同時(shí)不會(huì)有太大的開銷*/static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}

注意這里的異或運(yùn)算：(h = key.hashCode()) ^ (h >>> 16)
為什么要這么干呢？ 這個(gè)與HashMap中table下標(biāo)的計(jì)算有關(guān)

n = table.length; index = （n-1） & hash;

因?yàn)閠able的長(zhǎng)度都是2的冪，因此當(dāng)長(zhǎng)度較小時(shí)index僅與hash值的低n位有關(guān)，hash值的高位都被&操作置為0了，見下圖最后一列。

假設(shè)table.length=2^4=16，要插入的key的hashcode為1111 1111 1111 1111 1111 0000 1110 1010。

? ? ? ?圖中可以看出，(h = key.hashCode()) ^ (h >>> 16)操作將hashcode高位和低位的值進(jìn)行混合做異或運(yùn)算，混合后，低位的信息中加入了高位的信息，這樣高位的信息被變相的保留了下來。這樣做的好處是最后一步進(jìn)行（n-1） & hash時(shí)，摻雜的元素多了，那么生成的hash值的隨機(jī)性會(huì)增大。

2. resize()

擴(kuò)容(resize)：其實(shí)就是重新計(jì)算容量，之后重新定義一個(gè)新的容器，將原來容器中的元素放入其中。

2.1 什么時(shí)候擴(kuò)容： 在put操作時(shí)，即向容器中添加元素時(shí)，判斷當(dāng)前容器中元素的個(gè)數(shù)是否達(dá)到閾值（當(dāng)前數(shù)組長(zhǎng)度乘以加載因子的值）的時(shí)候，就要自動(dòng)擴(kuò)容了。

//return the tablefinal Node<K,V>[] resize() {// 保存當(dāng)前tableNode<K,V>[] oldTab = table;// 保存當(dāng)前table的容量和閾值int oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;// 初始化新的table容量和閾值 int newCap, newThr = 0;//resize（）函數(shù)在size　> threshold時(shí)被調(diào)用。oldCap大于 0 代表原來的 table 表非空if (oldCap > 0) {// 若舊table容量已超過最大容量，更新閾值為最大整型值，這樣以后就不會(huì)自動(dòng)擴(kuò)容了。并直接return if (oldCap >= MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return oldTab;}// 容量翻倍，使用左移，效率更高。因?yàn)槿萘靠偸?的冪else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)// 閾值翻倍。newThr = oldThr << 1; // double threshold}/*2. resize（）函數(shù)在table為空被調(diào)用。oldCap 小于等于 0 且 oldThr 大于0，代表用戶創(chuàng)建了一個(gè)HashMap,但是使用的構(gòu)造函數(shù)為HashMap(int initialCapacity, float loadFactor) 或 HashMap(int initialCapacity)或 HashMap(Map<? extends K, ? extends V> m)，導(dǎo)致 oldTab 為 null，oldCap 為0，oldThr 為用戶指定的 HashMap的初始容量。*/else if (oldThr > 0) // initial capacity was placed in threshold//當(dāng)table沒初始化時(shí)，threshold持有初始容量。還記得threshold = tableSizeFor(t)么;newCap = oldThr;/*3. resize（）函數(shù)在table為空被調(diào)用。oldCap 小于等于 0 且 oldThr 等于0，用戶調(diào)用 HashMap()構(gòu)造函4. 創(chuàng)建的　HashMap，所有值均采用默認(rèn)值，oldTab（Table）表為空，oldCap為0，oldThr等于0，*/else { // zero initial threshold signifies using defaultsnewCap = DEFAULT_INITIAL_CAPACITY;newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}// 新閾值為0if (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"})// 初始化tableNode<K,V>[] newTab = (Node<K,V>[])new Node[newCap];table = newTab;if (oldTab != null) {// 把 oldTab 中的節(jié)點(diǎn)　reHash 到　newTab 中去for (int j = 0; j < oldCap; ++j) {Node<K,V> e;if ((e = oldTab[j]) != null) {oldTab[j] = null;// 若節(jié)點(diǎn)是單個(gè)節(jié)點(diǎn)，直接在 newTab　中進(jìn)行重定位if (e.next == null)newTab[e.hash & (newCap - 1)] = e;// 若節(jié)點(diǎn)是　TreeNode 節(jié)點(diǎn)，要進(jìn)行 紅黑樹的 rehash　操作else if (e instanceof TreeNode)((TreeNode<K,V>)e).split(this, newTab, j, oldCap);// 若是鏈表，進(jìn)行鏈表的 rehash　操作else { // preserve orderNode<K,V> loHead = null, loTail = null;Node<K,V> hiHead = null, hiTail = null;Node<K,V> next;// 將同一桶中的元素根據(jù)(e.hash & oldCap)是否為0進(jìn)行分割（代碼后有圖解，可以回過//再來看），分成兩個(gè)不同的鏈表，完成rehashdo {next = e.next;// 根據(jù)算法　e.hash & oldCap 判斷節(jié)點(diǎn)位置rehash　后是否發(fā)生改變//最高位==0，這是索引不變的鏈表。if ((e.hash & oldCap) == 0) { if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;}//最高位==1 （這是索引發(fā)生改變的鏈表）else { if (hiTail == null)hiHead = e;elsehiTail.next = e;hiTail = e;}} while ((e = next) != null);if (loTail != null) { // 原bucket位置的尾指針不為空(即還有node) loTail.next = null; // 鏈表最后得有個(gè)nullnewTab[j] = loHead; // 鏈表頭指針放在新桶的相同下標(biāo)(j)處}if (hiTail != null) {hiTail.next = null;// rehash　后節(jié)點(diǎn)新的位置一定為原來基礎(chǔ)上加上oldCap，newTab[j + oldCap] = hiHead;}}}}}return newTab;} }

2.2 為什么鏈表節(jié)點(diǎn)只需要判斷最高位？

? ? ? ?我們使用的是2次冪的擴(kuò)展(指長(zhǎng)度擴(kuò)為原來2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移動(dòng)2次冪的位置。原因分析如下：

? ? ? ?hashMap的數(shù)組長(zhǎng)度一定保持2的次冪，比如16的二進(jìn)制表示為 10000，那么length-1就是15，二進(jìn)制為01111，同理擴(kuò)容后的數(shù)組長(zhǎng)度為32，二進(jìn)制表示為100000，length-1為31，二進(jìn)制表示為011111。
? ? ? ?從下圖可以我們也能看到這樣會(huì)保證低位全為1，而擴(kuò)容后只有一位差異，也就是多出了最左位的1，這樣在通過 h&(length-1)的時(shí)候，只要h對(duì)應(yīng)的最左邊的那一個(gè)差異位為0，就能保證得到的新的數(shù)組索引和老數(shù)組索引一致(大大減少了之前已經(jīng)散列良好的老數(shù)組的數(shù)據(jù)位置重新調(diào)換)，同樣h對(duì)應(yīng)的最左邊的那一個(gè)為1，新的索引位置就是oldIndex+oldCap。

? ? ? ?因此，我們?cè)跀U(kuò)充HashMap的時(shí)候，只需要看看原來的hash值新增的那個(gè)bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap”，省去了重新計(jì)算hash值的時(shí)間。

下面是從16擴(kuò)充為32的resize示意圖 ：

hashMap的容量是2的次冪還有一個(gè)好處是會(huì)使得數(shù)組索引index更加均勻:

? ? ? ?我們看到，上面的&運(yùn)算，高位是不會(huì)對(duì)結(jié)果產(chǎn)生影響的（hash函數(shù)采用各種位運(yùn)算可能也是為了使得低位更加散列），我們只關(guān)注低位bit，如果低位全部為1，那么對(duì)于h低位部分來說，任何一位的變化都會(huì)對(duì)結(jié)果產(chǎn)生影響，也就是說，要得到index=21這個(gè)存儲(chǔ)位置，h的低位只有這一種組合。這也是數(shù)組長(zhǎng)度設(shè)計(jì)為必須為2的次冪的原因。

? ? ? ?如果不是2的次冪，也就是低位不是全為1此時(shí)，要使得index=21，h的低位部分不再具有唯一性了，哈希沖突的幾率會(huì)變的更大，同時(shí)，index對(duì)應(yīng)的這個(gè)bit位無論如何不會(huì)等于1了，而對(duì)應(yīng)的那些數(shù)組位置也就被白白浪費(fèi)了。

3. putVal( )

//實(shí)現(xiàn)put和相關(guān)方法。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為空或者長(zhǎng)度為0，則resize()if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;//確定插入table的位置，算法是(n - 1) & hash，在n為2的冪時(shí)，相當(dāng)于取摸操作。找到key值對(duì)應(yīng)的槽并且是第一個(gè)，直接加入if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);//在table的i位置發(fā)生碰撞，有兩種情況，1、key值是一樣的，替換value值，//2、key值不一樣的有兩種處理方式：2.1、存儲(chǔ)在i位置的鏈表；2.2、存儲(chǔ)在紅黑樹中else {Node<K,V> e; K k;//第一個(gè)node的hash值即為要加入元素的hashif (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;//2.2else if (p instanceof TreeNode)e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//2.1else {//不是TreeNode,即為鏈表,遍歷鏈表for (int binCount = 0; ; ++binCount) {///鏈表的尾端也沒有找到key值相同的節(jié)點(diǎn)，則生成一個(gè)新的Node,//并且判斷鏈表的節(jié)點(diǎn)個(gè)數(shù)是不是到達(dá)轉(zhuǎn)換成紅黑樹的上界達(dá)到，則轉(zhuǎn)換成紅黑樹。if ((e = p.next) == null) {// 創(chuàng)建鏈表節(jié)點(diǎn)并插入尾部p.next = newNode(hash, key, value, null);超過了鏈表的設(shè)置長(zhǎng)度8就轉(zhuǎn)換成紅黑樹if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}//如果e不為空就替換舊的oldValue值if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold)resize();afterNodeInsertion(evict);return null;}

總結(jié)來將put操作就是以下幾個(gè)步驟：

檢查數(shù)組是否為空（因?yàn)閿?shù)組的初始化是放到put方法中），執(zhí)行resize()擴(kuò)容；

通過key的hash值計(jì)算在數(shù)組上的位置，如果該位置為null，直接添加節(jié)點(diǎn)到該位置。

如果該節(jié)點(diǎn)已經(jīng)有值，且hashcode和equals都相同，就覆蓋它返回old value

如果首節(jié)點(diǎn)是紅黑樹節(jié)點(diǎn)（TreeNode），將要插入的值添加到紅黑樹。

如果首節(jié)點(diǎn)是鏈表，就遍歷鏈表，是否存在相同的key，都沒有就添加到鏈表尾部。

最后判斷是否需要轉(zhuǎn)換成紅黑樹和擴(kuò)充

hash 沖突發(fā)生的幾種情況：
1.兩節(jié)點(diǎn)key 值相同（hash值一定相同），導(dǎo)致沖突；
2.兩節(jié)點(diǎn)key 值不同，由于 hash 函數(shù)的局限性導(dǎo)致hash 值相同，沖突；
3.兩節(jié)點(diǎn)key 值不同，hash 值不同，但 hash 值對(duì)數(shù)組長(zhǎng)度取模后相同，沖突；

總結(jié)

以上是生活随笔為你收集整理的面试再也不怕问到HashMap（一）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。