面試中一個hashmap到底能問出什么？看完這個我終于明白了-有解無憂

前言：

hashmap是面試中問的最多的一道題，關于它的底層原理和擴容機制是必問的，根據你對hashmap的回答，面試官能對你的基礎和技術有個大致的了解，這篇文章主要介紹了JAVA關于HashMap容易被提問的面試題，因為好久沒看的原因，所以今天就總結一下，文中題目提問頻率高的幾道題，本人在網上總結到的，相信對你的面試有一定幫助，想要入職JAVA的朋友可以了解下，

在這里插入圖片描述

另外本人整理收藏了20年多家公司面試知識點整理，以及各種Java核心知識點免費分享給大家，下方只是部分截圖想要資料的話也可以點擊795983544領取暗號CSDN，
在這里插入圖片描述
1.為什么我們建議在定義HashMap的時候，就指定它的初始化大小呢？

答：在當我們對HashMap初始化時，如果沒有為其設定初始化容量，那么系統會默認創建一個容量為16的大小的集合，當我們向HashMap中添加元素時，如果HashMap的容量值超過了它的臨界值（默認16*0.75=12）時，（0.75是HashMap的加載因子）HashMap將會重新擴容到下一個2的指數次冪（2^4=16 下一個2的指數次冪是2^5=32），由于HashMap擴容要進行resize的操作，頻繁的resize，會導致HashMap的性能下降，所以建議在確定HashMap集合的大小的情況下，指定其初始化大小，避免做過多的resize操作，導致性能下降，

2.HashMap什么時候進行擴容？

答：當我們不斷的向HashMap中添加元素時，它會判斷HashMap當前的容量值(當前元素的個數)是否超過了它的臨界值（在沒有指定其初始化大小時，默認16*0.75=12），如果添加的元素個數超過了臨界值，它就會開始進行擴容，

3.HashMap在擴容時，擴容到多大？

答：HashMap在擴容時，它會擴容到下一個2的指數次冪，即當前容量的2倍，比如當前容量是2^{4=16，將會擴容到下一個2的指數次冪2}5=32.

4.HashMap是如何進行擴容的？

答：HashMap進行擴容時會呼叫resize()函式，重新計算HashMap所需的新的容量，然后重新定義一個新的容器，將原陣列資料進行Hash, 放入新的容器中，這個程序將會導致HashMap的性能下降，

resize()函式的原始碼：

//HashMap 擴容操作
final Node<K,V>[] resize() {
  //保存當前table
  Node<K,V>[] oldTab = table;
  //保存當前table的容量
  int oldCap = (oldTab == null) ? 0 : oldTab.length;
  //保存當前閾值
  int oldThr = threshold;
  //初始化新的table容量和閾值
  int newCap, newThr = 0;
  
  //1. resize()函式在size(HashMap當前的元素個數) > threshold(當前閾值，默認16*0.75=12)時呼叫，
  //當oldCap(HashMap的元素個數)大于0表示原來的table表非空，oldCap(threshold)為oldCap x load_factor(加載因子：0.75)
  if (oldCap > 0) {
    //若舊table容量大于等于最大容量，更新閾值為Integer.MAX_VALUE(最大整形值)，這樣以后就不會自動擴容了
    if (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 //閾值翻倍
  }
  
  //2. resize()函式在table為空被呼叫，oldCap小于等于0且oldThr大于0，表示用戶使用HashMap的建構式創建了一個HashMap，
  //使用的建構式為HashMap(int initialCapacity, float loadFactor)或HashMap(int initialCapacity)或HashMap(Map<? extends K, ? extends V> m)，
  //導致了oldTab為null,oldCap為0，oldThr為用戶指定的HashMap的初始化容量
  else if (oldThr > 0) // initial capacity was placed in threshold
    newCap = oldThr; //當table沒有初始化時，threshold為初始容量， threshold = tableSizeFor(t);
  
  //3. resize()函式在table為空被呼叫，oldCap小于等于0且oldThr大于0，表示用戶使用HashMap的無參建構式HashMap()函式創建了一個HashMap，
  //此時，所有值均采用默認值，oldTab(table)表為空，oldCap為0，oldThr等于0.
  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; //新的tbale容量*加載因子
    newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
         (int)ft : Integer.MAX_VALUE);
  }
  threshold = newThr;
  @SuppressWarnings({"rawtypes","unchecked"})
    //初始化table
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
  table = newTab;
  if (oldTab != null) {
    //把oldTab中的節點reHash到newTab中去
    for (int j = 0; j < oldCap; ++j) {
      Node<K,V> e;
      if ((e = oldTab[j]) != null) {
        oldTab[j] = null;
      //如果節點是單個節點，直接在newTab中進行重定位
        if (e.next == null)
          newTab[e.hash & (newCap - 1)] = e;
      //如果節點是TreeNode節點，要進行紅黑樹的rehash操作
        else if (e instanceof TreeNode)
          ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
      //如果是鏈表，進行鏈表的rehash操作
        else { // preserve order
          Node<K,V> loHead = null, loTail = null;
          Node<K,V> hiHead = null, hiTail = null;
          Node<K,V> next;
        //將同一桶中的元素根據(e.hash & oldCap)是否為0進行分割，分成兩個不同的鏈表，完成rehash操作
          do {
            next = e.next;
         //根據演算法 e.hash & oldCap 判斷節點位置rehash后是否發生改變，最高位==0，這是索引不變的鏈表
            if ((e.hash & oldCap) == 0) {
              if (loTail == null)
                loHead = e;
              else
                loTail.next = e;
              loTail = e;
            }
         //最高位==1，這是索引發生改變的鏈表
            else {
              if (hiTail == null)
                hiHead = e;
              else
                hiTail.next = e;
              hiTail = e;
            }
          } while ((e = next) != null);
          if (loTail != null) { //原bucket位置的尾指標不為空(即還有node)
            loTail.next = null;  //鏈表最后一個節點為null
            newTab[j] = loHead; //鏈表的頭指標放在新桶的相同下標(j)處
          }
          if (hiTail != null) {
            hiTail.next = null;
            newTab[j + oldCap] = hiHead; //rehash后節點新的位置一定為原來基礎上加上oldCap
          }
        }
      }
    }
  }
  return newTab;
}

5.為什么說HashMap是執行緒不安全的？

答：HashMap在多執行緒并發時執行緒不安全，主要表現在下面兩個方面：

(1) 當向HashMap中put(添加)元素時導致的多執行緒資料不一致

比如有兩個執行緒 A 和 B ，首先 A 希望插入一個 key-value鍵值對到HashMap 中，它首先計算記錄所要落到的 hash 桶的索引坐標，然后獲取到該桶里面的鏈表頭結點，此時執行緒 A 的時間片用完了，而此時執行緒 B 被調度得以執行，和執行緒 A 一樣執行，只不過執行緒 B 成功將記錄插到了桶里面，假設執行緒 A 插入的記錄計算出來的 hash 桶索引和執行緒 B 要插入的記錄計算出來的 hash 桶索引是一樣的，那么當執行緒 B 成功插入之后，執行緒 A 再次被調度運行時，它依然持有過期的鏈表頭但是它對此一無所知，以至于它認為它應該這樣做，如此一來就覆寫了執行緒 B 插入的記錄，這樣執行緒 B 插入的記錄就憑空消失了，造成了資料不一致的行為，

簡單來說就是在多執行緒環境下，向HashMap集合中添加元素會存在覆寫的現象，導致了執行緒不安全，

(2) 當HashMap進行擴容呼叫resize()函式時引起死回圈

HashMap在put的時候，插入的元素超過了容量（由負載因子決定）的范圍就會觸發擴容操作，就是rehash，這個會重新將原陣列的內容重新hash到新的擴容陣列中，在多執行緒的環境下，存在同時其他的元素也在進行put操作，如果hash值相同，可能出現同時在同一陣列下用鏈表表示，造成倍訓，導致在get時會出現死回圈，所以HashMap是執行緒不安全的，

HashMap的執行緒不安全主要體現在下面兩個方面：

1.在JDK1.7中，當并發執行擴容操作時會造成環形鏈和資料丟失的情況，

2.在JDK1.8中，在并發執行put操作時會發生資料覆寫的情況，

6.說說HashMap 的資料結構

HashMap是一個key-value鍵值對的資料結構，從結構上來講在jdk1.8之前是用陣列加鏈表的方式實作，jdk1.8加了紅黑樹，HashMap陣列的默認初始長度是16，HashMap陣列只允許一個key為null，允許多個value為null

HashMap的內部實作，HashMap是使用陣列+鏈表+紅黑樹的形式實作的，其中陣列是一個一個Node[]陣列，我們叫他hash桶陣列，它上面存放的是key-value鍵值對的節點，HashMap是用hash表來存盤的，在HashMap里為解決hash沖突，使用鏈地址法，簡單來說就是陣列加鏈表的形式來解決，當資料被hash后，得到陣列下標，把資料放在對應下標的鏈表中，

HashMap是基于哈希表的Map介面的非同步實作，此實作提供所有可選的映射操作，并允許使用null值和null鍵，此類不保證映射的順序，特別是它不保證該順序恒久不變，HashMap實際上是一個“鏈表散列”的資料結構，即陣列和鏈表的結合體，HashMap底層就是一個陣列結構，陣列中的每一項又是一個鏈表，當新建一個HashMap的時候，就會初始化一個陣列，HashMap主干為一個Entry陣列，而每個Entry存放著一個鍵值對和同時指向另一個Entry的參考，如果發生哈希沖突，該參考即指向另一個Entry，

HashMap是由陣列+鏈表結構組成，陣列是HashMap主體，鏈表則是為了解決哈希沖突而存在，如果對于Entry不含鏈表的位置，對其操作的時間復雜度為O(1)，如果定位到具有鏈表的位置，則時間復雜度為O(n)，

HashMap中重要欄位:

transient int size ：實際儲存的KEY-VALUE對個數

int threshold ：閥值，當表為空的時候，該值初始容量為16，后期擴容使用

final float loadFactor ：負載因子，代表表的填充度，默認為0.75

transient int modCount ：用于快速失敗，迭代時拋出例外

在JDK1.8中 HashMap底層改為鏈表+陣列+紅黑樹的形式，當Hash沖突多次在同一個位置發生的時候，（確切的說是該位置鏈表長度大于8時），在此位置將用紅黑樹來儲存資料提高讀取效率.

HashMap 包含如下幾個構造器：

HashMap()：構建一個初始容量為 16，負載因子為 0.75 的 HashMap，

HashMap(int initialCapacity)：構建一個初始容量為 initialCapacity，負載因子為 0.75 的 HashMap，

HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的負載因子創建一個 HashMap，

HashMap的基礎構造器HashMap(int initialCapacity, float loadFactor)帶有兩個引數，它們是初始容量initialCapacity和負載因子loadFactor，

負載因子loadFactor衡量的是一個散串列的空間的使用程度，負載因子越大表示散串列的裝填程度越高，反之愈小，對于使用鏈表法的散串列來說，查找一個元素的平均時間是O(1+a)，因此如果負載因子越大，對空間的利用更充分，然而后果是查找效率的降低；如果負載因子太小，那么散串列的資料將過于稀疏，對空間造成嚴重浪費，

HashMap的實作中，通過threshold欄位來判斷HashMap的最大容量：

threshold = (int)(capacity * loadFactor);

結合負載因子的定義公式可知，threshold就是在此loadFactor和capacity對應下允許的最大元素數目，超過這個數目就重新resize，以降低實際的負載因子，默認的負載因子0.75是對空間和時間效率的一個平衡選擇，當容量超出此最大容量時， resize后的HashMap容量是容量的兩倍：

7.HashMap 的作業原理是什么?

一，存盤方式： Java中的HashMap是以鍵值對(key-value)的形式存盤元素的，

二，呼叫原理： HashMap需要一個hash函式，它使用hashCode()和equals()方法來向集合/從集合添加和檢索元素，當呼叫put()方法的時候，HashMap會計算key的hash值，然后把鍵值對存盤在集合中合適的索引上，如果key已經存在了，value會被更新成新值，

HashMap的實作原理：

利用key的hashCode重新hash計算出當前物件的元素在陣列中的下標
存盤時，如果出現hash值相同的key，此時有兩種情況，(1)如果key相同，則覆寫原始值；(2)如果key不同（出現沖突），則將當前的key-value放入鏈表中
獲取時，直接找到hash值對應的下標，再進一步判斷key是否相同，從而找到對應值，
理解了以上程序就不難明白HashMap是如何解決hash沖突的問題，核心就是使用了陣列的存盤方式，然后將沖突的key的物件放入鏈表中，一旦發現沖突就在鏈表中做進一步的對比，

總結：

本文著重講解了面試中 HashMap 面試題，相信讀者仔細品讀以后，對HashMap 的實作會有一個清晰地認識，JDK7 中的 HashMap 的實作原理屬于經典實作，不管 JDK7 是否已經再被使用，但是其基本原理還是值得學習！后續將繼續講解 JDK8 中的 HashMap實作原理，屆時將對比 JDK7，幫助讀者掌握兩者之間的共性和差異！

以上純屬個人總結，如有不對的，歡迎指出！感謝諸君的支持，點個贊吧！

另外本人整理收藏了20年多家公司面試知識點整理共127頁的PDF 以及各種知識點整理免費分享給大家，想要資料的話點擊795983544暗號CSDN自行領取，今天的分享就到這了，希望大家多多支持我，一個不甘平凡的小碼農！
在這里插入圖片描述

在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/163475.html

標籤：其他

上一篇：Github 與 Git，新手初次接觸的尷尬歷程

下一篇：11道精選阿里和華為的面試題Java技術面試題及對應答案