【原創】HashMap複習精講

引言

因爲近期忙着搬家，又偷懶了幾個禮拜！
其實我很早之前就想寫一篇關於HashMap的面試專題。對於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值同樣的情形，就在數組上的對應位置造成一條鏈表。

ps:這裏的hash值並非指hashcode，而是將hashcode高低十六位異或過的。至於爲何要這麼作，繼續往下看。

hash衝突你還知道哪些解決辦法？
比較出名的有四種(1)開放定址法(2)鏈地址法(3)再哈希法(4)公共溢出區域法

ps:你們有興趣拓展的，本身去搜一下就懂了，這個就不拓展了！
我用LinkedList代替數組結構能夠麼?
這裏我稍微說明一下，此題的意思是，源碼中是這樣的

Entry[] table = new Entry[capacity];

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

List<Entry> table = new LinkedList<Entry>();

是否可行?
答案很明顯，必須是能夠的。
既然是能夠的,爲何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、MD四、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在併發編程環境下有什麼問題啊?

• (1)多線程擴容，引發的死循環問題
• (2)多線程put的時候可能致使元素丟失
• (3)put非null元素後get出來的倒是null

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

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

你通常怎麼解決這些問題的？

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

(6)你通常用什麼做爲HashMap的key?

此題能夠組成以下連環炮來問

• 健能夠爲Null值麼?
• 你通常用什麼做爲HashMap的key?
• 我用可變類當HashMap的key有什麼問題?
• 若是讓你實現一個自定義的class做爲HashMap的key該如何實現？

健能夠爲Null值麼?
必須能夠，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<List<String>, Object> changeMap = new HashMap<>();
List<String> 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
null

若是讓你實現一個自定義的class做爲HashMap的key該如何實現？
此題考察兩個知識點

• 重寫hashcode和equals方法注意什麼?
• 如何設計一個不變類

針對問題一，記住下面四個原則便可
(1)兩個對象相等，hashcode必定相等
(2)兩個對象不等，hashcode不必定不等
(3)hashcode相等，兩個對象不必定相等
(4)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的面試題了，但願你們有所收穫！