面試再問HashMap，求你把這篇文章發給他！

時間 2021-06-30

標籤 java node 面試算法 segmentfault 後端數組安全微信數據結構欄目快樂工作简体版

原文原文鏈接

做者：超大隻烏龜
https://segmentfault.com/a/11...

總所周知 HashMap 是面試中常常問到的一個知識點，也是判斷一個候選人基礎是否紮實的標準之一，由於經過 HashMap 能夠引出不少知識點，好比數據結構(數組、鏈表、紅黑樹)、equals 和 hashcode 方法。java

除此以外還能夠引出線程安全的問題，HashMap 是我在初學階段學到的設計的最爲巧妙的集合，裏面有不少細節以及優化技巧都值得咱們深刻學習，話很少說先看看相關的面試題：node

• 默認大小、負載因子以及擴容倍數是多少面試

• 底層數據結構算法

• 如何處理 hash 衝突的segmentfault

• 如何計算一個 key 的 hash 值後端

• 數組長度爲何是 2 的冪次方數組

• 擴容、查找過程安全

若是上面的都能回答出來的話你就不須要看這篇文章了，那麼開始進入正文。微信

數據結構數據結構

• 在 JDK1.8 中，HashMap 是由數組+鏈表+紅黑樹構成

• 當一個值中要存儲到 HashMap 中的時候會根據 Key 的值來計算出他的 hash，經過 hash 值來確認存放到數組中的位置，若是發生 hash 衝突就以鏈表的形式存儲，當鏈表過長的話，HashMap 會把這個鏈表轉換成紅黑樹來存儲。

在看源碼以前咱們須要先看看一些基本屬性

//默認初始容量爲16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//默認負載因子爲0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//Hash數組(在resize()中初始化)
transient Node<K,V>[] table;
//元素個數
transient int size;
//容量閾值(元素個數超過該值會自動擴容)
int threshold;

table 數組裏面存放的是 Node 對象，Node 是 HashMap 的一個內部類，用來表示一個 key-value，源碼以下：

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);//^表示相同返回0，不一樣返回1
        //Objects.hashCode(o)————>return o != null ? o.hashCode() : 0;
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            //Objects.equals(1,b)————> return (a == b) || (a != null && a.equals(b));
            if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

總結：

• 默認初始容量爲 16，默認負載因子爲 0.75

• threshold = 數組長度 * loadFactor，當元素個數超過threshold(容量閾值)時，HashMap 會進行擴容操做

• table 數組中存放指向鏈表的引用

這裏須要注意的一點是 table 數組並非在構造方法裏面初始化的，它是在 resize(擴容)方法裏進行初始化的。

table 數組長度永遠爲 2 的冪次方

總所周知，HashMap 數組長度永遠爲 2 的冪次方(指的是 table 數組的大小)，那你有想過爲何嗎？

首先咱們須要知道 HashMap 是經過一個名爲 tableSizeFor 的方法來確保 HashMap 數組長度永遠爲2的冪次方的，源碼以下：

/*找到大於或等於 cap 的最小2的冪，用來作容量閾值*/
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;
}

tableSizeFor 的功能（不考慮大於最大容量的狀況）是返回大於等於輸入參數且最近的 2 的整數次冪的數。好比 10，則返回 16。

該算法讓最高位的 1 後面的位全變爲 1。最後再讓結果 n+1，即獲得了 2 的整數次冪的值了。

讓 cap-1 再賦值給 n 的目的是另找到的目標值大於或等於原值。例如二進制 1000，十進制數值爲 8。若是不對它減1而直接操做，將獲得答案 10000，即 16。顯然不是結果。減 1 後二進制爲 111，再進行操做則會獲得原來的數值 1000，即 8。經過一系列位運算大大提升效率。

那在什麼地方會用到 tableSizeFor 方法呢？

答案就是在構造方法裏面調用該方法來設置 threshold，也就是容量閾值。

這裏你可能又會有一個疑問：爲何要設置爲 threshold 呢？

由於在擴容方法裏第一次初始化 table 數組時會將 threshold 設置數組的長度，後續在講擴容方法時再介紹。推薦閱讀：HashMap 面試 21 問，此次要跪了！

/*傳入初始容量和負載因子*/
public HashMap(int initialCapacity, float loadFactor) {

    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +loadFactor);

    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}

那麼爲何要把數組長度設計爲 2 的冪次方呢？

我我的以爲這樣設計有如下幾個好處：

1. 當數組長度爲 2 的冪次方時，可使用位運算來計算元素在數組中的下標

HashMap 是經過 index=hash&(table.length-1) 這條公式來計算元素在 table 數組中存放的下標，就是把元素的 hash 值和數組長度減1的值作一個與運算，便可求出該元素在數組中的下標，這條公式其實等價於 hash%length，也就是對數組長度求模取餘，只不過只有當數組長度爲 2 的冪次方時，hash&(length-1) 纔等價於 hash%length，使用位運算能夠提升效率。

2. 增長 hash 值的隨機性，減小 hash 衝突

若是 length 爲 2 的冪次方，則 length-1 轉化爲二進制一定是 11111……的形式，這樣的話可使全部位置都能和元素 hash 值作與運算，若是是若是 length 不是 2 的次冪，好比 length 爲 15，則 length-1 爲 14，對應的二進制爲 1110，在和 hash 作與運算時，最後一位永遠都爲 0 ，浪費空間。HashMap 容量爲何老是爲 2 的次冪？推薦看下。

關注微信公衆號：Java技術棧，在後臺回覆：Java，能夠獲取我整理的 N 篇 Java 教程，都是乾貨。

擴容

HashMap 每次擴容都是創建一個新的 table 數組，長度和容量閾值都變爲原來的兩倍，而後把原數組元素從新映射到新數組上，具體步驟以下：

1. 首先會判斷 table 數組長度，若是大於 0 說明已被初始化過，那麼按當前 table 數組長度的 2 倍進行擴容，閾值也變爲原來的 2 倍

2. 若 table 數組未被初始化過，且 threshold(閾值)大於 0 說明調用了 HashMap(initialCapacity, loadFactor) 構造方法，那麼就把數組大小設爲 threshold

3. 若 table 數組未被初始化，且 threshold 爲 0 說明調用 HashMap() 構造方法，那麼就把數組大小設爲 16，threshold 設爲 16*0.75

4. 接着須要判斷若是不是第一次初始化，那麼擴容以後，要從新計算鍵值對的位置，並把它們移動到合適的位置上去，若是節點是紅黑樹類型的話則須要進行紅黑樹的拆分。

這裏有一個須要注意的點就是在 JDK1.8 HashMap 擴容階段從新映射元素時不須要像 1.7 版本那樣從新去一個個計算元素的 hash 值，而是經過 hash & oldCap 的值來判斷，若爲 0 則索引位置不變，不爲 0 則新索引=原索引+舊數組長度，爲何呢？具體緣由以下：

由於咱們使用的是 2 次冪的擴展(指長度擴爲原來 2 倍)，因此，元素的位置要麼是在原位置，要麼是在原位置再移動 2 次冪的位置。所以，咱們在擴充 HashMap 的時候，不須要像 JDK1.7 的實現那樣從新計算 hash，只須要看看原來的 hash 值新增的那個 bit 是 1 仍是 0 就行了，是 0 的話索引沒變，是 1 的話索引變成「原索引 +oldCap

這點其實也能夠看作長度爲 2 的冪次方的一個好處，也是 HashMap 1.7 和 1.8 之間的一個區別，具體源碼以下：

/*擴容*/
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;

    //一、若oldCap>0 說明hash數組table已被初始化
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }//按當前table數組長度的2倍進行擴容，閾值也變爲原來的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1;
    }//二、若數組未被初始化，而threshold>0說明調用了HashMap(initialCapacity)和HashMap(initialCapacity, loadFactor)構造器
    else if (oldThr > 0)
        newCap = oldThr;//新容量設爲數組閾值
    else { //三、若table數組未被初始化，且threshold爲0說明調用HashMap()構造方法
        newCap = DEFAULT_INITIAL_CAPACITY;//默認爲16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//16*0.75
    }

    //若計算過程當中，閾值溢出歸零，則按閾值公式從新計算
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    //建立新的hash數組，hash數組的初始化也是在這裏完成的
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    //若是舊的hash數組不爲空，則遍歷舊數組並映射到新的hash數組
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;//GC
                if (e.next == null)//若是隻連接一個節點，從新計算並放入新數組
                    newTab[e.hash & (newCap - 1)] = e;
                //如果紅黑樹，則須要進行拆分
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else {
                    //rehash————>從新映射到新數組
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        /*注意這裏使用的是：e.hash & oldCap，若爲0則索引位置不變，不爲0則新索引=原索引+舊數組長度*/
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

在擴容方法裏面還涉及到有關紅黑樹的幾個知識點：

鏈表樹化

指的就是把鏈表轉換成紅黑樹，樹化須要知足如下兩個條件：

鏈表長度大於等於 8
table 數組長度大於等於 64

爲何 table 數組容量大於等於 64 才樹化？

由於當 table 數組容量比較小時，鍵值對節點 hash 的碰撞率可能會比較高，進而致使鏈表長度較長。這個時候應該優先擴容，而不是立馬樹化。

紅黑樹拆分

拆分就是指擴容後對元素從新映射時，紅黑樹可能會被拆分紅兩條鏈表。

因爲篇幅有限，有關紅黑樹這裏就不展開了。

查找

HashMap 的查找是很是快的，要查找一個元素首先得知道 key 的 hash 值，在 HashMap 中並非直接經過 key 的 hashcode 方法獲取哈希值，而是經過內部自定義的 hash 方法計算哈希值，咱們來看看其實現：

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

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

知道如何計算 hash 值後咱們來看看 get 方法

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;//hash(key)不等於key.hashCode
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; //指向hash數組
    Node<K,V> first, e; //first指向hash數組連接的第一個節點，e指向下一個節點
    int n;//hash數組長度
    K k;
    /*(n - 1) & hash ————>根據hash值計算出在數組中的索引index（至關於對數組長度取模，這裏用位運算進行了優化）*/
    if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
        //基本類型用==比較，其它用euqals比較
        if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            //若是first是TreeNode類型，則調用紅黑樹查找方法
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {//向後遍歷
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

這裏要注意的一點就是在 HashMap 中用 (n - 1) & hash 計算 key 所對應的索引 index（至關於對數組長度取模，這裏用位運算進行了優化），這點在上面已經說過了，就再也不廢話了。

插入

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

1. 當 table 數組爲空時，經過擴容的方式初始化 table

2. 經過計算鍵的 hash 值求出下標後，若該位置上沒有元素(沒有發生 hash 衝突)，則新建 Node 節點插入

3. 若發生了 hash 衝突，遍歷鏈表查找要插入的 key 是否已經存在，存在的話根據條件判斷是否用新值替換舊值

4. 若是不存在，則將元素插入鏈表尾部，並根據鏈表長度決定是否將鏈表轉爲紅黑樹

5. 判斷鍵值對數量是否大於閾值，大於的話則進行擴容操做

先看完上面的流程，再來看源碼會簡單不少，源碼以下：

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    Node<K,V>[] tab;//指向hash數組
    Node<K,V> p;//初始化爲table中第一個節點
    int n, i;//n爲數組長度，i爲索引

    //tab被延遲到插入新數據時再進行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //若是數組中不包含Node引用，則新建Node節點存入數組中便可
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);//new Node<>(hash, key, value, next)
    else {
        Node<K,V> e; //若是要插入的key-value已存在，用e指向該節點
        K k;
        //若是第一個節點就是要插入的key-value，則讓e指向第一個節點（p在這裏指向第一個節點）
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //若是p是TreeNode類型，則調用紅黑樹的插入操做（注意：TreeNode是Node的子類）
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //對鏈表進行遍歷，並用binCount統計鏈表長度
            for (int binCount = 0; ; ++binCount) {
                //若是鏈表中不包含要插入的key-value，則將其插入到鏈表尾部
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //若是鏈表長度大於或等於樹化閾值，則進行樹化操做
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                //若是要插入的key-value已存在則終止遍歷，不然向後遍歷
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //若是e不爲null說明要插入的key-value已存在
        if (e != null) {
            V oldValue = e.value;
            //根據傳入的onlyIfAbsent判斷是否要更新舊值
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //鍵值對數量超過閾值時，則進行擴容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);//也是空函數？回調？不知道幹嗎的
    return null;
}

從源碼也能夠看出 table 數組是在第一次調用 put 方法後才進行初始化的。

刪除

HashMap 的刪除操做並不複雜，僅需三個步驟便可完成。

1. 定位桶位置

2. 遍歷鏈表找到相等的節點

3. 第三步刪除節點

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {
    Node<K,V>[] tab;
    Node<K,V> p;
    int n, index;
    //一、定位元素桶位置
    if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e;
        K k;
        V v;
        // 若是鍵的值與鏈表第一個節點相等，則將 node 指向該節點
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            // 若是是 TreeNode 類型，調用紅黑樹的查找邏輯定位待刪除節點
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                // 二、遍歷鏈表，找到待刪除節點
                do {
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 三、刪除節點，並修復鏈表或紅黑樹
        if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

注意：刪除節點後可能破壞了紅黑樹的平衡性質，removeTreeNode 方法會對紅黑樹進行變色、旋轉等操做來保持紅黑樹的平衡結構，這部分比較複雜。

遍歷

在工做中 HashMap 的遍歷操做也是很是經常使用的，也許有不少小夥伴喜歡用 for-each 來遍歷，可是你知道其中有哪些坑嗎？

看下面的例子，當咱們在遍歷 HashMap 的時候，若使用 remove 方法刪除元素時會拋出 ConcurrentModificationException 異常

Map<String, Integer> map = new HashMap<>();
map.put("1", 1);
map.put("2", 2);
map.put("3", 3);
for (String s : map.keySet()) {
    if (s.equals("2"))
        map.remove("2");
}

這就是常說的 fail-fast(快速失敗)機制，這個就須要從一個變量提及

transient int modCount;

在 HashMap 中有一個名爲 modCount 的變量，它用來表示集合被修改的次數，修改指的是插入元素或刪除元素，能夠回去看看上面插入刪除的源碼，在最後都會對 modCount 進行自增。

當咱們在遍歷 HashMap 時，每次遍歷下一個元素前都會對 modCount 進行判斷，若和原來的不一致說明集合結果被修改過了，而後就會拋出異常，這是 Java 集合的一個特性，咱們這裏以 keySet 爲例，看看部分相關源碼：

public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        ks = new KeySet();
        keySet = ks;
    }
    return ks;
}

final class KeySet extends AbstractSet<K> {
    public final Iterator<K> iterator()     { return new KeyIterator(); }
    // 省略部分代碼
}

final class KeyIterator extends HashIterator implements Iterator<K> {
    public final K next() { return nextNode().key; }
}

/*HashMap迭代器基類，子類有KeyIterator、ValueIterator等*/
abstract class HashIterator {
    Node<K,V> next;        //下一個節點
    Node<K,V> current;     //當前節點
    int expectedModCount;  //修改次數
    int index;             //當前索引
    //無參構造
    HashIterator() {
        expectedModCount = modCount;
        Node<K,V>[] t = table;
        current = next = null;
        index = 0;
        //找到第一個不爲空的桶的索引
        if (t != null && size > 0) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
    }
    //是否有下一個節點
    public final boolean hasNext() {
        return next != null;
    }
    //返回下一個節點
    final Node<K,V> nextNode() {
        Node<K,V>[] t;
        Node<K,V> e = next;
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();//fail-fast
        if (e == null)
            throw new NoSuchElementException();
        //當前的鏈表遍歷完了就開始遍歷下一個鏈表
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }
    //刪除元素
    public final void remove() {
        Node<K,V> p = current;
        if (p == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        K key = p.key;
        removeNode(hash(key), key, null, false, false);//調用外部的removeNode
        expectedModCount = modCount;
    }
}

相關代碼以下，能夠看到若 modCount 被修改了則會拋出 ConcurrentModificationException 異常。

if (modCount != expectedModCount)
    throw new ConcurrentModificationException();

那麼如何在遍歷時刪除元素呢？

咱們能夠看看迭代器自帶的 remove 方法，其中最後兩行代碼以下：

removeNode(hash(key), key, null, false, false);//調用外部的removeNode
expectedModCount = modCount;

意思就是會調用外部 remove 方法刪除元素後，把 modCount 賦值給 expectedModCount，這樣的話二者一致就不會拋出異常了，因此咱們應該這樣寫：

Map<String, Integer> map = new HashMap<>();
map.put("1", 1);
map.put("2", 2);
map.put("3", 3);
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()){
    if (iterator.next().equals("2"))
        iterator.remove();
}

這裏還有一個知識點就是在遍歷 HashMap 時，咱們會發現遍歷的順序和插入的順序不一致，這是爲何？

在 HashIterator 源碼裏面能夠看出，它是先從桶數組中找到包含鏈表節點引用的桶。而後對這個桶指向的鏈表進行遍歷。遍歷完成後，再繼續尋找下一個包含鏈表節點引用的桶，找到繼續遍歷。找不到，則結束遍歷。這就解釋了爲何遍歷和插入的順序不一致，不懂的同窗請看下圖：

equasl 和 hashcode

爲何添加到 HashMap 中的對象須要重寫 equals() 和 hashcode() 方法？

簡單看個例子，這裏以 Person 爲例：

public class Person {
    Integer id;
    String name;

    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) return false;
        if (obj == this) return true;
        if (obj instanceof Person) {
            Person person = (Person) obj;
            if (this.id == person.id)
                return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Person p1 = new Person(1, "aaa");
        Person p2 = new Person(1, "bbb");
        HashMap<Person, String> map = new HashMap<>();
        map.put(p1, "這是p1");
        System.out.println(map.get(p2));
    }
}

•原生的 equals 方法是使用 == 來比較對象的
•原生的 hashCode 值是根據內存地址換算出來的一個值

Person 類重寫 equals 方法來根據 id 判斷是否相等，當沒有重寫 hashcode 方法時，插入 p1 後便沒法用 p2 取出元素，這是由於 p1 和 p2 的哈希值不相等。

HashMap 插入元素時是根據元素的哈希值來肯定存放在數組中的位置，所以HashMap 的 key 須要重寫 equals 和 hashcode 方法。

總結

本文描述了 HashMap 的實現原理，並結合源碼作了進一步的分析，後續有空的話會聊聊有關 HashMap 的線程安全問題，但願本篇文章能幫助到你們，同時也歡迎討論指正，謝謝支持！

推薦去個人博客閱讀更多：

1.Java JVM、集合、多線程、新特性系列教程

2.Spring MVC、Spring Boot、Spring Cloud 系列教程

3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

4.Java、後端、架構、阿里巴巴等大廠最新面試題

以爲不錯，別忘了點贊+轉發哦！