日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時(shí)間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
一文看懂HashMap

HashMap是面試中經(jīng)常問到的一個(gè)知識(shí)點(diǎn)，也是判斷一個(gè)候選人基礎(chǔ)是否扎實(shí)的標(biāo)準(zhǔn)之一，因?yàn)橥ㄟ^HashMap可以引出很多知識(shí)點(diǎn)，比如數(shù)據(jù)結(jié)構(gòu)(數(shù)組、鏈表、紅黑樹)、equals和hashcode方法，除此之外還可以引出線程安全的問題，HashMap是我在初學(xué)階段學(xué)到的設(shè)計(jì)的最為巧妙的集合，里面有很多細(xì)節(jié)以及優(yōu)化技巧都值得我們深入學(xué)習(xí)，本文將會(huì)涉及到以下問題

成都創(chuàng)新互聯(lián)公司是專業(yè)的巧家網(wǎng)站建設(shè)公司，巧家接單;提供網(wǎng)站建設(shè)、網(wǎng)站制作,網(wǎng)頁設(shè)計(jì),網(wǎng)站設(shè)計(jì),建網(wǎng)站,PHP網(wǎng)站建設(shè)等專業(yè)做網(wǎng)站服務(wù);采用PHP框架,可快速的進(jìn)行巧家網(wǎng)站開發(fā)網(wǎng)頁制作和功能擴(kuò)展;專業(yè)做搜索引擎喜愛的網(wǎng)站,專業(yè)的做網(wǎng)站團(tuán)隊(duì),希望更多企業(yè)前來合作!

  •  默認(rèn)大小、負(fù)載因子以及擴(kuò)容倍數(shù)
  •  底層數(shù)據(jù)結(jié)構(gòu)
  •  如何處理hash沖突
  •  如何計(jì)算key的hash值
  •  數(shù)組長度為什么是2的冪次方
  •  查找、插入、擴(kuò)容過程

如果上面的都能回答出來的話那么這篇文章可能不太適合你，話不多說進(jìn)入正文。

注意：本文源碼都是以JDK1.8版本講解

數(shù)據(jù)結(jié)構(gòu)

  •  在 JDK1.8 中，HashMap 是由 數(shù)組+鏈表+紅黑樹構(gòu)成(1.7版本是數(shù)組+鏈表)
  •  當(dāng)一個(gè)值中要存儲(chǔ)到HashMap中的時(shí)候會(huì)根據(jù)Key的值來計(jì)算出他的hash，通過hash值來確認(rèn)存放到數(shù)組中的位置，如果發(fā)生hash沖突就以鏈表的形式存儲(chǔ)，當(dāng)鏈表過長的話，HashMap會(huì)把這個(gè)鏈表轉(zhuǎn)換成紅黑樹來存儲(chǔ)，如圖所示：

在看源碼之前我們需要先看看一些基本屬性 

 
 
 
 
    
  
  
  
  
  1. //默認(rèn)初始容量為16  
    2. 
  
  
  
  
  2. static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;  
    3. 
  
  
  
  
  3. //默認(rèn)負(fù)載因子為0.75  
    4. 
  
  
  
  
  4. static final float DEFAULT_LOAD_FACTOR = 0.75f;  
    5. 
  
  
  
  
  5. //Hash數(shù)組(在resize()中初始化)  
    6. 
  
  
  
  
  6. transient Node[] table;  
    7. 
  
  
  
  
  7. //元素個(gè)數(shù)  
    8. 
  
  
  
  
  8. transient int size;  
    9. 
  
  
  
  
  9. //容量閾值(元素個(gè)數(shù)超過該值會(huì)自動(dòng)擴(kuò)容)    
    10. 
  
  
  
  
  10. int threshold; 
    11.

table數(shù)組里面存放的是Node對(duì)象，Node是HashMap的一個(gè)內(nèi)部類，用來表示一個(gè)key-value，源碼如下： 

 
 
 
 
    
  
  
  
  
  1. static class Node implements Map.Entry {  
    2. 
  
  
  
  
  2.     final int hash;  
    3. 
  
  
  
  
  3.     final K key;  
    4. 
  
  
  
  
  4.     V value;  
    5. 
  
  
  
  
  5.     Node next;  
    6. 
  
  
  
  
  6.     Node(int hash, K key, V value, Node next) {  
    7. 
  
  
  
  
  7.         this.hash = hash;  
    8. 
  
  
  
  
  8.         this.key = key;  
    9. 
  
  
  
  
  9.         this.value = value;  
    10. 
  
  
  
  
  10.         this.next = next;  
    11. 
  
  
  
  
  11.     }   
    12. 
  
  
  
  
  12.     public final K getKey()        { return key; }  
    13. 
  
  
  
  
  13.     public final V getValue()      { return value; }  
    14. 
  
  
  
  
  14.     public final String toString() { return key + "=" + value; }  
    15. 
  
  
  
  
  15.     public final int hashCode() {  
    16. 
  
  
  
  
  16.         return Objects.hashCode(key) ^ Objects.hashCode(value);//^表示相同返回0，不同返回1  
    17. 
  
  
  
  
  17.         //Objects.hashCode(o)————>return o != null ? o.hashCode() : 0;  
    18. 
  
  
  
  
  18.     }  
    19. 
  
  
  
  
  19.     public final V setValue(V newValue) {  
    20. 
  
  
  
  
  20.         V oldValue = value;  
    21. 
  
  
  
  
  21.         value = newValue;  
    22. 
  
  
  
  
  22.         return oldValue;  
    23. 
  
  
  
  
  23.     } 
    24. 
  
  
  
  
  24.     public final boolean equals(Object o) {  
    25. 
  
  
  
  
  25.         if (o == this)  
    26. 
  
  
  
  
  26.             return true;  
    27. 
  
  
  
  
  27.         if (o instanceof Map.Entry) {  
    28. 
  
  
  
  
  28.             Map.Entry e = (Map.Entry)o;  
    29. 
  
  
  
  
  29.             //Objects.equals(1,b)————> return (a == b) || (a != null && a.equals(b));  
    30. 
  
  
  
  
  30.             if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue()))  
    31. 
  
  
  
  
  31.                 return true;  
    32. 
  
  
  
  
  32.         }  
    33. 
  
  
  
  
  33.         return false;  
    34. 
  
  
  
  
  34.     }  
    35. 
  
  
  
  
  35. } 
    36.

總結(jié)

  •  默認(rèn)初始容量為16，默認(rèn)負(fù)載因子為0.75
  •  threshold = 數(shù)組長度 * loadFactor，當(dāng)元素個(gè)數(shù)超過threshold(容量閾值)時(shí)，HashMap會(huì)進(jìn)行擴(kuò)容操作
  •  table數(shù)組中存放指向鏈表的引用

這里需要注意的一點(diǎn)是table數(shù)組并不是在構(gòu)造方法里面初始化的，它是在resize(擴(kuò)容)方法里進(jìn)行初始化的。

table數(shù)組長度永遠(yuǎn)為2的冪次方

總所周知，HashMap數(shù)組長度永遠(yuǎn)為2的冪次方(指的是table數(shù)組的大小)，那你有想過為什么嗎？

首先我們需要知道HashMap是通過一個(gè)名為tableSizeFor的方法來確保HashMap數(shù)組長度永遠(yuǎn)為2的冪次方的，源碼如下： 

 
 
 
 
    
  
  
  
  
  1. /*找到大于或等于 cap 的最小2的冪，用來做容量閾值*/  
    2. 
  
  
  
  
  2. static final int tableSizeFor(int cap) {  
    3. 
  
  
  
  
  3.     int n = cap - 1;  
    4. 
  
  
  
  
  4.     n |= n >>> 1;  
    5. 
  
  
  
  
  5.     n |= n >>> 2;  
    6. 
  
  
  
  
  6.     n |= n >>> 4;  
    7. 
  
  
  
  
  7.     n |= n >>> 8;  
    8. 
  
  
  
  
  8.     n |= n >>> 16;  
    9. 
  
  
  
  
  9.     return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;  
    10. 
  
  
  
  
  10. } 
    11.

tableSizeFor的功能（不考慮大于最大容量的情況）是返回大于等于輸入?yún)?shù)且最近的2的整數(shù)次冪的數(shù)。比如10，則返回16。

該算法讓最高位的1后面的位全變?yōu)?。最后再讓結(jié)果n+1，即得到了2的整數(shù)次冪的值了。

讓cap-1再賦值給n的目的是另找到的目標(biāo)值大于或等于原值。例如二進(jìn)制1000，十進(jìn)制數(shù)值為8。如果不對(duì)它減1而直接操作，將得到答案10000，即16。顯然不是結(jié)果。減1后二進(jìn)制為111，再進(jìn)行操作則會(huì)得到原來的數(shù)值1000，即8。通過一系列位運(yùn)算大大提高效率。

那在什么地方會(huì)用到tableSizeFor方法呢？

答案就是在構(gòu)造方法里面調(diào)用該方法來設(shè)置threshold，也就是容量閾值。

這里你可能又會(huì)有一個(gè)疑問：為什么要設(shè)置為threshold呢？

因?yàn)樵跀U(kuò)容方法里第一次初始化table數(shù)組時(shí)會(huì)將threshold設(shè)置數(shù)組的長度，后續(xù)在講擴(kuò)容方法時(shí)再介紹。 

 
 
 
 
    
  
  
  
  
  1. /*傳入初始容量和負(fù)載因子*/  
    2. 
  
  
  
  
  2. public HashMap(int initialCapacity, float loadFactor) {     
    3. 
  
  
  
  
  3.     if (initialCapacity < 0)  
    4. 
  
  
  
  
  4.         throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);  
    5. 
  
  
  
  
  5.     if (initialCapacity > MAXIMUM_CAPACITY)  
    6. 
  
  
  
  
  6.         initialCapacity = MAXIMUM_CAPACITY;  
    7. 
  
  
  
  
  7.     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
    8. 
  
  
  
  
  8.         throw new IllegalArgumentException("Illegal load factor: " +loadFactor);       
    9. 
  
  
  
  
  9.     this.loadFactor = loadFactor;  
    10. 
  
  
  
  
  10.     this.threshold = tableSizeFor(initialCapacity);  
    11. 
  
  
  
  
  11. } 
    12.
  • 那么為什么要把數(shù)組長度設(shè)計(jì)為2的冪次方呢？

我個(gè)人覺得這樣設(shè)計(jì)有以下幾個(gè)好處：

    1、當(dāng)數(shù)組長度為2的冪次方時(shí)，可以使用位運(yùn)算來計(jì)算元素在數(shù)組中的下標(biāo)

HashMap是通過index=hash&(table.length-1)這條公式來計(jì)算元素在table數(shù)組中存放的下標(biāo)，就是把元素的hash值和數(shù)組長度減1的值做一個(gè)與運(yùn)算，即可求出該元素在數(shù)組中的下標(biāo)，這條公式其實(shí)等價(jià)于hash%length，也就是對(duì)數(shù)組長度求模取余，只不過只有當(dāng)數(shù)組長度為2的冪次方時(shí)，hash&(length-1)才等價(jià)于hash%length，使用位運(yùn)算可以提高效率。

    2、 增加hash值的隨機(jī)性，減少hash沖突

如果 length 為 2 的冪次方，則 length-1 轉(zhuǎn)化為二進(jìn)制必定是 11111……的形式，這樣的話可以使所有位置都能和元素hash值做與運(yùn)算，如果是如果 length 不是2的次冪，比如length為15，則length-1為14，對(duì)應(yīng)的二進(jìn)制為1110，在和hash 做與運(yùn)算時(shí)，最后一位永遠(yuǎn)都為0 ，浪費(fèi)空間。

擴(kuò)容

HashMap每次擴(kuò)容都是建立一個(gè)新的table數(shù)組，長度和容量閾值都變?yōu)樵瓉淼膬杀?，然后把原?shù)組元素重新映射到新數(shù)組上，具體步驟如下：

  1.  首先會(huì)判斷table數(shù)組長度，如果大于0說明已被初始化過，那么按當(dāng)前table數(shù)組長度的2倍進(jìn)行擴(kuò)容，閾值也變?yōu)樵瓉淼?倍
  2.  若table數(shù)組未被初始化過，且threshold(閾值)大于0說明調(diào)用了HashMap(initialCapacity, loadFactor)構(gòu)造方法，那么就把數(shù)組大小設(shè)為threshold
  3.  若table數(shù)組未被初始化，且threshold為0說明調(diào)用HashMap()構(gòu)造方法，那么就把數(shù)組大小設(shè)為16，threshold設(shè)為16*0.75
  4.  接著需要判斷如果不是第一次初始化，那么擴(kuò)容之后，要重新計(jì)算鍵值對(duì)的位置，并把它們移動(dòng)到合適的位置上去，如果節(jié)點(diǎn)是紅黑樹類型的話則需要進(jìn)行紅黑樹的拆分。

這里有一個(gè)需要注意的點(diǎn)就是在JDK1.8 HashMap擴(kuò)容階段重新映射元素時(shí)不需要像1.7版本那樣重新去一個(gè)個(gè)計(jì)算元素的hash值，而是通過hash & oldCap的值來判斷，若為0則索引位置不變，不為0則新索引=原索引+舊數(shù)組長度，為什么呢？具體原因如下：

因?yàn)槲覀兪褂玫氖?次冪的擴(kuò)展(指長度擴(kuò)為原來2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移動(dòng)2次冪的位置。因此，我們?cè)跀U(kuò)充HashMap的時(shí)候，不需要像JDK1.7的實(shí)現(xiàn)那樣重新計(jì)算hash，只需要看看原來的hash值新增的那個(gè)bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap

這點(diǎn)其實(shí)也可以看做長度為2的冪次方的一個(gè)好處，也是HashMap 1.7和1.8之間的一個(gè)區(qū)別，具體源碼如下： 

 
 
 
 
    
  
  
  
  
  1. /*擴(kuò)容*/  
    2. 
  
  
  
  
  2. final Node[] resize() {  
    3. 
  
  
  
  
  3.     Node[] oldTab = table;  
    4. 
  
  
  
  
  4.     int oldCap = (oldTab == null) ? 0 : oldTab.length;  
    5. 
  
  
  
  
  5.     int oldThr = threshold;  
    6. 
  
  
  
  
  6.     int newCap, newThr = 0;   
    7. 
  
  
  
  
  7.     //1、若oldCap>0 說明hash數(shù)組table已被初始化  
    8. 
  
  
  
  
  8.     if (oldCap > 0) {  
    9. 
  
  
  
  
  9.         if (oldCap >= MAXIMUM_CAPACITY) {  
    10. 
  
  
  
  
  10.             threshold = Integer.MAX_VALUE;  
    11. 
  
  
  
  
  11.             return oldTab;  
    12. 
  
  
  
  
  12.         }//按當(dāng)前table數(shù)組長度的2倍進(jìn)行擴(kuò)容，閾值也變?yōu)樵瓉淼?倍  
    13. 
  
  
  
  
  13.         else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)  
    14. 
  
  
  
  
  14.             newThr = oldThr << 1;   
    15. 
  
  
  
  
  15.     }//2、若數(shù)組未被初始化，而threshold>0說明調(diào)用了HashMap(initialCapacity)和HashMap(initialCapacity, loadFactor)構(gòu)造器  
    16. 
  
  
  
  
  16.     else if (oldThr > 0)  
    17. 
  
  
  
  
  17.         newCap = oldThr;//新容量設(shè)為數(shù)組閾值  
    18. 
  
  
  
  
  18.     else { //3、若table數(shù)組未被初始化，且threshold為0說明調(diào)用HashMap()構(gòu)造方法         
    19. 
  
  
  
  
  19.          newCap = DEFAULT_INITIAL_CAPACITY;//默認(rèn)為16  
    20. 
  
  
  
  
  20.         newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//16*0.75  
    21. 
  
  
  
  
  21.     } 
    22. 
  
  
  
  
  22.      //若計(jì)算過程中，閾值溢出歸零，則按閾值公式重新計(jì)算  
    23. 
  
  
  
  
  23.     if (newThr == 0) {  
    24. 
  
  
  
  
  24.         float ft = (float)newCap * loadFactor;  
    25. 
  
  
  
  
  25.         newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?  
    26. 
  
  
  
  
  26.                   (int)ft : Integer.MAX_VALUE);  
    27. 
  
  
  
  
  27.     }  
    28. 
  
  
  
  
  28.     threshold = newThr;  
    29. 
  
  
  
  
  29.     //創(chuàng)建新的hash數(shù)組，hash數(shù)組的初始化也是在這里完成的  
    30. 
  
  
  
  
  30.     Node[] newTab = (Node[])new Node[newCap];  
    31. 
  
  
  
  
  31.     table = newTab;  
    32. 
  
  
  
  
  32.     //如果舊的hash數(shù)組不為空，則遍歷舊數(shù)組并映射到新的hash數(shù)組  
    33. 
  
  
  
  
  33.     if (oldTab != null) {  
    34. 
  
  
  
  
  34.         for (int j = 0; j < oldCap; ++j) {  
    35. 
  
  
  
  
  35.             Node e;  
    36. 
  
  
  
  
  36.             if ((e = oldTab[j]) != null) {  
    37. 
  
  
  
  
  37.                 oldTab[j] = null;//GC  
    38. 
  
  
  
  
  38.                 if (e.next == null)//如果只鏈接一個(gè)節(jié)點(diǎn)，重新計(jì)算并放入新數(shù)組  
    39. 
  
  
  
  
  39.                     newTab[e.hash & (newCap - 1)] = e;  
    40. 
  
  
  
  
  40.                 //若是紅黑樹，則需要進(jìn)行拆分      
    41. 
  
  
  
  
  41.                 else if (e instanceof TreeNode)  
    42. 
  
  
  
  
  42.                     ((TreeNode)e).split(this, newTab, j, oldCap);  
    43. 
  
  
  
  
  43.                 else {   
    44. 
  
  
  
  
  44.                     //rehash————>重新映射到新數(shù)組  
    45. 
  
  
  
  
  45.                     Node loHead = null, loTail = null;  
    46. 
  
  
  
  
  46.                     Node hiHead = null, hiTail = null;  
    47. 
  
  
  
  
  47.                     Node next;  
    48. 
  
  
  
  
  48.                     do {  
    49. 
  
  
  
  
  49.                         next = e.next;  
    50. 
  
  
  
  
  50.                         /*注意這里使用的是：e.hash & oldCap，若為0則索引位置不變，不為0則新索引=原索引+舊數(shù)組長度*/  
    51. 
  
  
  
  
  51.                         if ((e.hash & oldCap) == 0) {  
    52. 
  
  
  
  
  52.                             if (loTail == null)  
    53. 
  
  
  
  
  53.                                 loHead = e;  
    54. 
  
  
  
  
  54.                             else  
    55. 
  
  
  
  
  55.                                 loTail.next = e;  
    56. 
  
  
  
  
  56.                             loTail = e;  
    57. 
  
  
  
  
  57.                         }  
    58. 
  
  
  
  
  58.                         else {  
    59. 
  
  
  
  
  59.                             if (hiTail == null)  
    60. 
  
  
  
  
  60.                                 hiHead = e;  
    61. 
  
  
  
  
  61.                             else  
    62. 
  
  
  
  
  62.                                 hiTail.next = e;  
    63. 
  
  
  
  
  63.                             hiTail = e;  
    64. 
  
  
  
  
  64.                         }  
    65. 
  
  
  
  
  65.                     } while ((e = next) != null);  
    66. 
  
  
  
  
  66.                     if (loTail != null) {  
    67. 
  
  
  
  
  67.                         loTail.next = null;  
    68. 
  
  
  
  
  68.                         newTab[j] = loHead;  
    69. 
  
  
  
  
  69.                     }  
    70. 
  
  
  
  
  70.                     if (hiTail != null) {  
    71. 
  
  
  
  
  71.                         hiTail.next = null;  
    72. 
  
  
  
  
  72.                         newTab[j + oldCap] = hiHead;  
    73. 
  
  
  
  
  73.                     }  
    74. 
  
  
  
  
  74.                 }  
    75. 
  
  
  
  
  75.             }  
    76. 
  
  
  
  
  76.         }  
    77. 
  
  
  
  
  77.     }  
    78. 
  
  
  
  
  78.     return newTab;  
    79. 
  
  
  
  
  79. } 
    80.

在擴(kuò)容方法里面還涉及到有關(guān)紅黑樹的幾個(gè)知識(shí)點(diǎn)：

鏈表樹化

指的就是把鏈表轉(zhuǎn)換成紅黑樹，樹化需要滿足以下兩個(gè)條件：

  •  鏈表長度大于等于8
  •  table數(shù)組長度大于等于64

為什么table數(shù)組容量大于等于64才樹化？

因?yàn)楫?dāng)table數(shù)組容量比較小時(shí)，鍵值對(duì)節(jié)點(diǎn) hash 的碰撞率可能會(huì)比較高，進(jìn)而導(dǎo)致鏈表長度較長。這個(gè)時(shí)候應(yīng)該優(yōu)先擴(kuò)容，而不是立馬樹化。

紅黑樹拆分

拆分就是指擴(kuò)容后對(duì)元素重新映射時(shí)，紅黑樹可能會(huì)被拆分成兩條鏈表。

由于篇幅有限，有關(guān)紅黑樹這里就不展開了。

查找

HashMap的查找是非?？斓?，要查找一個(gè)元素首先得知道key的hash值，在HashMap中并不是直接通過key的hashcode方法獲取哈希值，而是通過內(nèi)部自定義的hash方法計(jì)算哈希值，我們來看看其實(shí)現(xiàn)： 

 
 
 
 
    
  
  
  
  
  1. static final int hash(Object key) {  
    2. 
  
  
  
  
  2.     int h;  
    3. 
  
  
  
  
  3.     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);  
    4. 
  
  
  
  
  4. } 
    5.

(h = key.hashCode()) ^ (h >>> 16) 是為了讓高位數(shù)據(jù)與低位數(shù)據(jù)進(jìn)行異或，變相的讓高位數(shù)據(jù)參與到計(jì)算中，int有 32 位，右移16位就能讓低16位和高16位進(jìn)行異或，也是為了增加hash值的隨機(jī)性。

知道如何計(jì)算hash值后我們來看看get方法 

 
 
 
 
    
  
  
  
  
  1. public V get(Object key) {  
    2. 
  
  
  
  
  2.     Node e;  
    3. 
  
  
  
  
  3.     return (e = getNode(hash(key), key)) == null ? null : e.value;//hash(key)不等于key.hashCode  
    4. 
  
  
  
  
  4. } 
    5. 
  
  
  
  
  5. final Node getNode(int hash, Object key) {  
    6. 
  
  
  
  
  6.     Node[] tab; //指向hash數(shù)組  
    7. 
  
  
  
  
  7.     Node first, e; //first指向hash數(shù)組鏈接的第一個(gè)節(jié)點(diǎn)，e指向下一個(gè)節(jié)點(diǎn)  
    8. 
  
  
  
  
  8.     int n;//hash數(shù)組長度  
    9. 
  
  
  
  
  9.     K k;  
    10. 
  
  
  
  
  10.     /*(n - 1) & hash ————>根據(jù)hash值計(jì)算出在數(shù)組中的索引index（相當(dāng)于對(duì)數(shù)組長度取模，這里用位運(yùn)算進(jìn)行了優(yōu)化）*/  
    11. 
  
  
  
  
  11.     if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {  
    12. 
  
  
  
  
  12.         //基本類型用==比較，其它用euqals比較  
    13. 
  
  
  
  
  13.         if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))  
    14. 
  
  
  
  
  14.             return first;  
    15. 
  
  
  
  
  15.         if ((e = first.next) != null) {  
    16. 
  
  
  
  
  16.             //如果first是TreeNode類型，則調(diào)用紅黑樹查找方法  
    17. 
  
  
  
  
  17.             if (first instanceof TreeNode)  
    18. 
  
  
  
  
  18.                 return ((TreeNode)first).getTreeNode(hash, key);  
    19. 
  
  
  
  
  19.             do {//向后遍歷  
    20. 
  
  
  
  
  20.                 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))  
    21. 
  
  
  
  
  21.                     return e;  
    22. 
  
  
  
  
  22.             } while ((ee = e.next) != null);  
    23. 
  
  
  
  
  23.         }  
    24. 
  
  
  
  
  24.     }  
    25. 
  
  
  
  
  25.     return null;  
    26. 
  
  
  
  
  26. } 
    27.

這里要注意的一點(diǎn)就是在HashMap中用 (n - 1) & hash 計(jì)算key所對(duì)應(yīng)的索引index（相當(dāng)于對(duì)數(shù)組長度取模，這里用位運(yùn)算進(jìn)行了優(yōu)化），這點(diǎn)在上面已經(jīng)說過了，就不再廢話了。

插入

我們先來看看插入元素的步驟：

  1.  當(dāng)table數(shù)組為空時(shí)，通過擴(kuò)容的方式初始化table
  2.  通過計(jì)算鍵的hash值求出下標(biāo)后，若該位置上沒有元素(沒有發(fā)生hash沖突)，則新建Node節(jié)點(diǎn)插入
  3.  若發(fā)生了hash沖突，遍歷鏈表查找要插入的key是否已經(jīng)存在，存在的話根據(jù)條件判斷是否用新值替換舊值
  4.  如果不存在，則將元素插入鏈表尾部，并根據(jù)鏈表長度決定是否將鏈表轉(zhuǎn)為紅黑樹
  5.  判斷鍵值對(duì)數(shù)量是否大于閾值，大于的話則進(jìn)行擴(kuò)容操作

先看完上面的流程，再來看源碼會(huì)簡單很多，源碼如下： 

 
 
 
 
    
  
  
  
  
  1. public V put(K key, V value) {  
    2. 
  
  
  
  
  2.     return putVal(hash(key), key, value, false, true);  
    3. 
  
  
  
  
  3. }  
    4. 
  
  
  
  
  4. final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {  
    5. 
  
  
  
  
  5.     Node[] tab;//指向hash數(shù)組  
    6. 
  
  
  
  
  6.     Node p;//初始化為table中第一個(gè)節(jié)點(diǎn)  
    7. 
  
  
  
  
  7.     int n, i;//n為數(shù)組長度，i為索引   
    8. 
  
  
  
  
  8.     //tab被延遲到插入新數(shù)據(jù)時(shí)再進(jìn)行初始化  
    9. 
  
  
  
  
  9.     if ((tab = table) == null || (n = tab.length) == 0)  
    10. 
  
  
  
  
  10.         n = (tab = resize()).length;  
    11. 
  
  
  
  
  11.     //如果數(shù)組中不包含Node引用，則新建Node節(jié)點(diǎn)存入數(shù)組中即可      
    12. 
  
  
  
  
  12.     if ((p = tab[i = (n - 1) & hash]) == null)  
    13. 
  
  
  
  
  13.         tab[i] = newNode(hash, key, value, null);//new Node<>(hash, key, value, next)  
    14. 
  
  
  
  
  14.     else {  
    15. 
  
  
  
  
  15.         Node e; //如果要插入的key-value已存在，用e指向該節(jié)點(diǎn)  
    16. 
  
  
  
  
  16.         K k;  
    17. 
  
  
  
  
  17.         //如果第一個(gè)節(jié)點(diǎn)就是要插入的key-value，則讓e指向第一個(gè)節(jié)點(diǎn)（p在這里指向第一個(gè)節(jié)點(diǎn)）  
    18. 
  
  
  
  
  18.         if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))  
    19. 
  
  
  
  
  19.             e = p;  
    20. 
  
  
  
  
  20.         //如果p是TreeNode類型，則調(diào)用紅黑樹的插入操作（注意：TreeNode是Node的子類）  
    21. 
  
  
  
  
  21.         else if (p instanceof TreeNode)  
    22. 
  
  
  
  
  22.             e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);  
    23. 
  
  
  
  
  23.         else {  
    24. 
  
  
  
  
  24.             //對(duì)鏈表進(jìn)行遍歷，并用binCount統(tǒng)計(jì)鏈表長度  
    25. 
  
  
  
  
  25.             for (int binCount = 0; ; ++binCount) {  
    26. 
  
  
  
  
  26.                 //如果鏈表中不包含要插入的key-value，則將其插入到鏈表尾部  
    27. 
  
  
  
  
  27.                 if ((e = p.next) == null) {  
    28. 
  
  
  
  
  28.                     p.next = newNode(hash, key, value, null);  
    29. 
  
  
  
  
  29.                     //如果鏈表長度大于或等于樹化閾值，則進(jìn)行樹化操作  
    30. 
  
  
  
  
  30.                     if (binCount >= TREEIFY_THRESHOLD - 1)  
    31. 
  
  
  
  
  31.                         treeifyBin(tab, hash);  
    32. 
  
  
  
  
  32.                     break;  
    33. 
  
  
  
  
  33.                 }  
    34. 
  
  
  
  
  34.                 //如果要插入的key-value已存在則終止遍歷，否則向后遍歷  
    35. 
  
  
  
  
  35.                 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))  
    36. 
  
  
  
  
  36.                     break;  
    37. 
  
  
  
  
  37.                 p = e; 
    38. 
  
  
  
  
  38.              }  
    39. 
  
  
  
  
  39.         }  
    40. 
  
  
  
  
  40.         //如果e不為null說明要插入的key-value已存在  
    41. 
  
  
  
  
  41.         if (e != null) {  
    42. 
  
  
  
  
  42.             V oldValue = e.value;  
    43. 
  
  
  
  
  43.             //根據(jù)傳入的onlyIfAbsent判斷是否要更新舊值  
    44. 
  
  
  
  
  44.             if (!onlyIfAbsent || oldValue == null)  
    45. 
  
  
  
  
  45.                 e.value = value;  
    46. 
  
  
  
  
  46.             afterNodeAccess(e);  
    47. 
  
  
  
  
  47.             return oldValue;  
    48. 
  
  
  
  
  48.         }  
    49. 
  
  
  
  
  49.     }  
    50. 
  
  
  
  
  50.     ++modCount;  
    51. 
  
  
  
  
  51.     //鍵值對(duì)數(shù)量超過閾值時(shí)，則進(jìn)行擴(kuò)容  
    52. 
  
  
  
  
  52.     if (++size > threshold)  
    53. 
  
  
  
  
  53.         resize();  
    54. 
  
  
  
  
  54.     afterNodeInsertion(evict);//也是空函數(shù)？回調(diào)？不知道干嘛的  
    55. 
  
  
  
  
  55.     return null;  
    56. 
  
  
  
  
  56. } 
    57.

從源碼也可以看出table數(shù)組是在第一次調(diào)用put方法后才進(jìn)行初始化的。

這里還有一個(gè)知識(shí)點(diǎn)就是在JDK1.8版本HashMap是在鏈表尾部插入元素的，而在1.7版本里是插入鏈表頭部的，1.7版本這么設(shè)計(jì)的原因可能是作者認(rèn)為新插入的元素使用到的頻率會(huì)比較高，插入頭部的話可以減少遍歷次數(shù)。

那為什么1.8改成尾插法了呢？主要是因?yàn)轭^插法在多線程環(huán)境下可能會(huì)導(dǎo)致兩個(gè)節(jié)點(diǎn)互相引用，形成死循環(huán)，由于此文主要講解1.8版本，感興趣的小伙伴可以去看看1.7版本的源碼。

刪除

HashMap的刪除操作并不復(fù)雜，僅需三個(gè)步驟即可完成。

  1.  定位桶位置
  2.  遍歷鏈表找到相等的節(jié)點(diǎn)
  3.  第三步刪除節(jié)點(diǎn) 
 
 
 
 
    
  
  
  
  
  1. public V remove(Object key) {  
    2. 
  
  
  
  
  2.     Node e;  
    3. 
  
  
  
  
  3.     return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;  
    4. 
  
  
  
  
  4. }  
    5. 
  
  
  
  
  5. final Node removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {  
    6. 
  
  
  
  
  6.     Node[] tab;   
    7. 
  
  
  
  
  7.     Node p;   
    8. 
  
  
  
  
  8.     int n, index;  
    9. 
  
  
  
  
  9.     //1、定位元素桶位置  
    10. 
  
  
  
  
  10.     if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {  
    11. 
  
  
  
  
  11.         Node node = null, e;   
    12. 
  
  
  
  
  12.         K k;   
    13. 
  
  
  
  
  13.         V v;  
    14. 
  
  
  
  
  14.         // 如果鍵的值與鏈表第一個(gè)節(jié)點(diǎn)相等，則將 node 指向該節(jié)點(diǎn)  
    15. 
  
  
  
  
  15.         if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))  
    16. 
  
  
  
  
  16.             node = p;  
    17. 
  
  
  
  
  17.         else if ((e = p.next) != null) {    
    18. 
  
  
  
  
  18.             // 如果是 TreeNode 類型，調(diào)用紅黑樹的查找邏輯定位待刪除節(jié)點(diǎn)  
    19. 
  
  
  
  
  19.             if (p instanceof TreeNode)  
    20. 
  
  
  
  
  20.                 node = ((TreeNode)p).getTreeNode(hash, key);  
    21. 
  
  
  
  
  21.             else {  
    22. 
  
  
  
  
  22.                 // 2、遍歷鏈表，找到待刪除節(jié)點(diǎn)  
    23. 
  
  
  
  
  23.                 do {  
    24. 
  
  
  
  
  24.                     if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {  
    25. 
  
  
  
  
  25.                         node = e;  
    26. 
  
  
  
  
  26.                         break;  
    27. 
  
  
  
  
  27.                     } 
    28. 
  
  
  
  
  28.                      p = e;  
    29. 
  
  
  
  
  29.                 } while ((ee = e.next) != null);  
    30. 
  
  
  
  
  30.             }  
    31. 
  
  
  
  
  31.         }          
    32. 
  
  
  
  
  32.         // 3、刪除節(jié)點(diǎn)，并修復(fù)鏈表或紅黑樹  
    33. 
  
  
  
  
  33.         if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {  
    34. 
  
  
  
  
  34.             if (node instanceof TreeNode)  
    35. 
  
  
  
  
  35.                 ((TreeNode)node).removeTreeNode(this, tab, movable);  
    36. 
  
  
  
  
  36.             else if (node == p)  
    37. 
  
  
  
  
  37.                 tab[index] = node.next;  
    38. 
  
  
  
  
  38.             else  
    39. 
  
  
  
  
  39.                 p.next = node.next;  
    40. 
  
  
  
  
  40.             ++modCount;  
    41. 
  
  
  
  
  41.             --size;  
    42. 
  
  
  
  
  42.             afterNodeRemoval(node);  
    43. 
  
  
  
  
  43.             return node;  
    44. 
  
  
  
  
  44.         }  
    45. 
  
  
  
  
  45.     }  
    46. 
  
  
  
  
  46.     return null;  
    47. 
  
  
  
  
  47. } 
    48.

注意：刪除節(jié)點(diǎn)后可能破壞了紅黑樹的平衡性質(zhì)，removeTreeNode方法會(huì)對(duì)紅黑樹進(jìn)行變色、旋轉(zhuǎn)等操作來保持紅黑樹的平衡結(jié)構(gòu)，這部分比較復(fù)雜，感興趣的小伙伴可看下面這篇文章：紅黑樹詳解

遍歷

在工作中HashMap的遍歷操作也是非常常用的，也許有很多小伙伴喜歡用for-each來遍歷，但是你知道其中有哪些坑嗎？

看下面的例子，當(dāng)我們?cè)诒闅vHashMap的時(shí)候，若使用remove方法刪除元素時(shí)會(huì)拋出ConcurrentModificationException異常   

 
 
 
 
    
  
  
  
  
  1. Map map = new HashMap<>();  
    2. 
  
  
  
  
  2.        map.put("1", 1);  
    3. 
  
  
  
  
  3.        map.put("2", 2);  
    4. 
  
  
  
  
  4.        map.put("3", 3);  
    5. 
  
  
  
  
  5.        for (String s : map.keySet()) {  
    6. 
  
  
  
  
  6.            if (s.equals("2"))   
    7. 
  
  
  
  
  7.                map.remove("2");                                                 
    
                                                本文題目：一文看懂HashMap                                                
    
                                                文章鏈接：http://www.dlmjj.cn/article/ccsddho.html