戳藍字「CSDN雲計算」關注我們哦！

對於JAVA求職者來說，HashMap可謂是集合類的重中之重，甚至你在複習的時候，其他集合類都不用看，專攻HashMap即可。然而，鑒於網上大部分的關於HashMap的面試方向文章，煙哥看過後都不是太滿意。因此，斗膽嘗試也寫一篇關於HashMap的面試專題文章!

(1)HashMap的實現原理?

此題可以組成如下連環炮來問

• 你看過HashMap源碼嘛，知道原理嘛?

• 為什麼用數組+鍊表？

• hash衝突你還知道哪些解決辦法？

• 我用LinkedList代替數組結構可以麼?

• 既然是可以的,為什麼HashMap不用LinkedList,而選用數組?

• 你看過HashMap源碼嘛，知道原理嘛?

針對這個問題，嗯，當然是必須看過HashMap源碼。至於原理，請看下圖：

HashMap採用Entry數組來存儲key-value對，每一個鍵值對組成了一個Entry實體，Entry類實際上是一個單向的鍊表結構，它具有Next指針，可以連接下一個Entry實體。只是在JDK1.8中，鍊表長度大於8的時候，鍊表會轉成紅黑樹！

為什麼用數組+鍊表？數組是用來確定桶的位置，利用元素的key的hash值對數組長度取模得到。鍊表是用來解決hash衝突問題，當出現hash值一樣的情形，就在數組上的對應位置形成一條鍊表。這裡的hash值並不是指hashcode，而是將hashcode高低十六位異或過的。至於為什麼要這麼做，繼續往下看。

hash衝突你還知道哪些解決辦法？比較出名的有：開放定址法、鏈地址法、再哈希法和公共溢出區域法。

我用LinkedList代替數組結構可以麼?這裡我稍微說明一下，此題的意思是，源碼中是這樣的：

Entry table = new Entry[capacity];

ps：Entry就是一個鍊表節點。那我用下面這樣表示：

List table = new LinkedList;

是否可行?答案很明顯，必須是可以的。既然是可以的，為什麼HashMap不用LinkedList,而選用數組?因為用數組效率最高！在HashMap中，定位桶的位置是利用元素的key的哈希值對數組長度取模得到。此時，我們已得到桶的位置。顯然數組的查找效率比LinkedList大。那ArrayList，底層也是數組，查找也快啊，為啥不用ArrayList?(煙哥寫到這裡的時候，不禁覺得自己真有想法，自己把自己問死了，還好我靈機一動想出了答案)

因為採用基本數組結構，擴容機制可以自己定義，HashMap中數組擴容剛好是2的次冪，在做取模運算的效率高。而ArrayList的擴容機制是1.5倍擴容，那ArrayList為什麼是1.5倍擴容這就不在本文說明了。

(2)HashMap在什麼條件下擴容?

此題可以組成如下連環炮來問

• HashMap在什麼條件下擴容?

• 為什麼擴容是2的n次冪?

• 為什麼為什麼要先高16位異或低16位再取模運算?

HashMap在什麼條件下擴容?如果bucket滿了(超過load factor*current capacity)，就要resize。load factor為0.75，為了最大程度避免哈希衝突。current capacity為當前數組大小。

為什麼擴容是2的次冪?HashMap為了存取高效，要儘量較少碰撞，就是要儘量把數據分配均勻，每個鍊表長度大致相同，這個實現就在把數據存到哪個鍊表中的算法；這個算法實際就是取模，hash%length。但是，大家都知道這種運算不如位移運算快。因此，源碼中做了優化hash&(length-1)。也就是說hash%length==hash&(length-1)那為什麼是2的n次方呢？因為2的n次方實際就是1後面n個0，2的n次方-1，實際就是n個1。例如長度為8時候，3&(8-1)=3 2&(8-1)=2 ，不同位置上，不碰撞。而長度為5的時候，3&(5-1)=0 2&(5-1)=0，都在0上，出現碰撞了。所以，保證容積是2的n次方，是為了保證在做(length-1)的時候，每一位都能&1 ，也就是和1111……1111111進行與運算。

為什麼為什麼要先高16位異或低16位再取模運算?我先曬一下，jdk1.8里的hash方法。1.7的比較複雜，咱就不看了。

hashmap這麼做，只是為了降低hash衝突的幾率。打個比方，當我們的length為16的時候，哈希碼(字符串「abcabcabcabcabc」的key對應的哈希碼)對(16-1)與操作，對於多個key生成的hashCode，只要哈希碼的後4位為0，不論不論高位怎麼變化，最終的結果均為0。如下圖所示：

而加上高16位異或低16位的「擾動函數」後，結果如下：

可以看到: 擾動函數優化前：1954974080 % 16 = 1954974080 & (16 - 1) = 0 擾動函數優化後：1955003654 % 16 = 1955003654 & (16 - 1) = 6 很顯然，減少了碰撞的幾率。

(3)講講hashmap的get/put的過程?

此題可以組成如下連環炮來問：

• 知道hashmap中put元素的過程是什麼樣麼?

• 知道hashmap中get元素的過程是什麼樣麼？

• 你還知道哪些hash算法？

• 說說String中hashcode的實現?(此題很多大廠問過)

知道hashmap中put元素的過程是什麼樣麼?對key的hashCode做hash運算，計算index;如果沒碰撞直接放到bucket里；如果碰撞了，以鍊表的形式存在buckets後；如果碰撞導致鍊表過長(大於等於TREEIFY_THRESHOLD)，就把鍊表轉換成紅黑樹(JDK1.8中的改動)；如果節點已經存在就替換old value(保證key的唯一性)；如果bucket滿了(超過load factor*current capacity)，就要resize。

知道hashmap中get元素的過程是什麼樣麼?對key的hashCode做hash運算，計算index;如果在bucket里的第一個節點裡直接命中，則直接返回；如果有衝突，則通過key.equals(k)去查找對應的Entry;若為樹，則在樹中通過key.equals(k)查找，O(logn)；若為鍊表，則在鍊表中通過key.equals(k)查找，O(n)。

你還知道哪些hash算法？

先說一下hash算法幹嘛的，Hash函數是指把一個大範圍映射到一個小範圍。把大範圍映射到一個小範圍的目的往往是為了節省空間，使得數據容易保存。比較出名的有MurmurHash、MD4、MD5等等。

說說String中hashcode的實現?(此題頻率很高)

public int hashCode { int h = hash; if (h == 0 && value.length > 0) { char val = value;
for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; } return h;}

String類中的hashCode計算方法還是比較簡單的，就是以31為權，每一位為字符的ASCII值進行運算，用自然溢出來等效取模。哈希計算公式可以計為s[0]31^(n-1) + s[1]31^(n-2) + … + s[n-1] 那為什麼以31為質數呢?主要是因為31是一個奇質數，所以31*i=32*i-i=(i<<5)-i，這種位移與減法結合的計算相比一般的運算快很多。

(4)為什麼hashmap的在鍊表元素數量超過8時改為紅黑樹?

此題可以組成如下連環炮來問：

• 知道jdk1.8中hashmap改了啥麼?

• 為什麼在解決hash衝突的時候，不直接用紅黑樹?而選擇先用鍊表，再轉紅黑樹?

• 我不用紅黑樹，用二叉查找樹可以麼?

• 那為什麼閥值是8呢?

• 當鍊表轉為紅黑樹後，什麼時候退化為鍊表?

知道jdk1.8中hashmap改了啥麼?

• 由數組+鍊表的結構改為數組+鍊表+紅黑樹。

• 優化了高位運算的hash算法：h^(h>>>16)

• 擴容後，元素要麼是在原位置，要麼是在原位置再移動2次冪的位置，且鍊表順序不變。

最後一條是重點，因為最後一條的變動，hashmap在1.8中，不會在出現死循環問題。為什麼在解決hash衝突的時候，不直接用紅黑樹?而選擇先用鍊表，再轉紅黑樹?

因為紅黑樹需要進行左旋，右旋，變色這些操作來保持平衡，而單鍊表不需要。當元素小於8個當時候，此時做查詢操作，鍊表結構已經能保證查詢性能。當元素大於8個的時候，此時需要紅黑樹來加快查詢速度，但是新增節點的效率變慢了。因此，如果一開始就用紅黑樹結構，元素太少，新增效率又比較慢，無疑這是浪費性能的。

我不用紅黑樹，用二叉查找樹可以麼?

可以。但是二叉查找樹在特殊情況下會變成一條線性結構（這就跟原來使用鍊表結構一樣了，造成很深的問題），遍歷查找會非常慢。那為什麼閥值是8呢?不知道，等jdk作者來回答。這道題，網上能找到的答案都是扯淡。

我隨便貼一個牛客網的答案，如下圖所示：

看出bug沒？交點是6.64？交點分明是4，好麼。log4=2，4/2=2。jdk作者選擇8，一定經過了嚴格的運算，覺得在長度為8的時候，與其保證鍊表結構的查找開銷，不如轉換為紅黑樹，改為維持其平衡開銷。

當鍊表轉為紅黑樹後，什麼時候退化為鍊表?

為6的時候退轉為鍊表。中間有個差值7可以防止鍊表和樹之間頻繁的轉換。假設一下，如果設計成鍊表個數超過8則鍊表轉換成樹結構，鍊表個數小於8則樹結構轉換成鍊表，如果一個HashMap不停的插入、刪除元素，鍊表個數在8左右徘徊，就會頻繁的發生樹轉鍊表、鍊表轉樹，效率會很低。

(5)HashMap的並發問題?

此題可以組成如下連環炮來問：

• HashMap在並發編程環境下有什麼問題啊?

• 在jdk1.8中還有這些問題麼?

• 你一般怎麼解決這些問題的？

HashMap在並發編程環境下有什麼問題啊?

• 多線程擴容，引起的死循環問題；

• 多線程put的時候可能導致元素丟失；

• put非元素後get出來的卻是。

在jdk1.8中還有這些問題麼?

在jdk1.8中，死循環問題已經解決。其他兩個問題還是存在。

你一般怎麼解決這些問題的？

比如ConcurrentHashmap，Hashtable等線程安全等集合類。

(6)你一般用什麼作為HashMap的key?

此題可以組成如下連環炮來問：

• 健可以為值麼?

• 你一般用什麼作為HashMap的key?

• 我用可變類當HashMap的key有什麼問題?

• 如果讓你實現一個自定義的class作為HashMap的key該如何實現？

健可以為值麼?必須可以，key為null的時候，hash算法最後的值以0來計算，也就是放在數組的第一個位置。

你一般用什麼作為HashMap的key?

一般用Integer、String這種不可變類當HashMap當key，而且String最為常用。

• (1)因為字符串是不可變的，所以在它創建的時候hashcode就被緩存了，不需要重新計算。這就使得字符串很適合作為Map中的鍵，字符串的處理速度要快過其它的鍵對象。這就是HashMap中的鍵往往都使用字符串。

• (2)因為獲取對象的時候要用到equals和hashCode方法，那麼鍵對象正確的重寫這兩個方法是非常重要的,這些類已經很規範的覆寫了hashCode以及equals方法。

我用可變類當HashMap的key有什麼問題?

hashcode可能發生改變，導致put進去的值，無法get出，如下所示：

HashMap, Object> changeMap = new HashMap<>;List list = new ArrayList<>;list.add("hello");Object objectValue = new Object;changeMap.put(list, objectValue);System.out.println(changeMap.get(list));list.add("hello world");//hashcode發生了改變System.out.println(changeMap.get(list));輸出值如下java.lang.Object@74a14482

如果讓你實現一個自定義的class作為HashMap的key該如何實現？

此題考察兩個知識點：

• 重寫hashcode和equals方法注意什麼?

• 如何設計一個不變類

針對問題一，記住這幾個原則即可：兩個對象相等，hashcode一定相等；兩個對象不等，hashcode不一定不等；hashcode相等，兩個對象不一定相等；hashcode不等，兩個對象一定不等。

針對問題二，記住如何寫一個不可變類。

(1)類添加final修飾符，保證類不被繼承。

如果類可以被繼承會破壞類的不可變性機制，只要繼承類覆蓋父類的方法並且繼承類可以改變成員變量值，那麼一旦子類以父類的形式出現時，不能保證當前類是否可變。

(2)保證所有成員變量必須私有，並且加上final修飾通過這種方式保證成員變量不可改變。但只做到這一步還不夠，因為如果是對象成員變量有可能再外部改變其值。所以第4點彌補這個不足。

(3)不提供改變成員變量的方法，包括setter避免通過其他接口改變成員變量的值，破壞不可變特性。

(4)通過構造器初始化所有成員，進行深拷貝(deep copy)。如果構造器傳入的對象直接賦值給成員變量，還是可以通過對傳入對象的修改進而導致改變內部變量的值。例如：

public final class ImmutableDemo {  private final int myArray;  public ImmutableDemo(int[] array) {  this.myArray = array; // wrong  } }

這種方式不能保證不可變性，myArray和array指向同一塊內存地址，用戶可以在ImmutableDemo之外通過修改array對象的值來改變myArray內部的值。為了保證內部的值不被修改，可以採用深度copy來創建一個新內存保存傳入的值。正確做法：

public final class MyImmutableDemo {  private final int myArray;  public MyImmutableDemo(int[] array) {  this.myArray = array.clone;  } }

(5)在getter方法中，不要直接返回對象本身，而是克隆對象，並返回對象的拷貝。這種做法也是防止對象外泄，防止通過getter獲得內部可變成員對象後對成員變量直接操作，導致成員變量發生改變。

這篇文章能概括大部分HashMap的面試題了，希望大家有所收穫！