一文看懂HashMap面試考點

HashMap是面試中經常問到的一個知識點，也是判斷一個候選人基礎是否紮實的标準之一，因為通過HashMap可以引出很多知識點，比如資料結構(數組、連結清單、紅黑樹)、equals和hashcode方法，除此之外還可以引出線程安全的問題，HashMap是我在初學階段學到的設計的最為巧妙的集合，裡面有很多細節以及優化技巧都值得我們深入學習，本文将會涉及到以下問題

預設大小、負載因子以及擴容倍數
底層資料結構
如何處理hash沖突
如何計算key的hash值
數組長度為什麼是2的幂次方
查找、插入、擴容過程

如果上面的都能回答出來的話那麼這篇文章可能不太适合你，話不多說進入正文。

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

資料結構

在 JDK1.8 中，HashMap 是由 數組+連結清單+紅黑樹 構成(1.7版本是數組+連結清單)
當一個值中要存儲到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設定數組的長度，後續在講擴容方法時再介紹。

/*傳入初始容量和負載因子*/
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每次擴容都是建立一個新的table數組，長度和容量門檻值都變為原來的兩倍，然後把原數組元素重新映射到新數組上，具體步驟如下：

首先會判斷table數組長度，如果大于0說明已被初始化過，那麼 按目前table數組長度的2倍進行擴容，門檻值也變為原來的2倍
若table數組未被初始化過，且threshold(門檻值)大于0說明調用了 HashMap(initialCapacity, loadFactor) 構造方法，那麼就把數組大小設為threshold
若table數組未被初始化，且threshold為0說明調用 HashMap() 構造方法，那麼就把數組大小設為 16 ，threshold設為 16*0.75
接着需要判斷如果不是第一次初始化，那麼擴容之後，要重新計算鍵值對的位置，并把它們移動到合适的位置上去，如果節點是紅黑樹類型的話則需要進行紅黑樹的拆分。

這裡有一個需要注意的點就是在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;
    
    //1、若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; 
    }//2、若數組未被初始化，而threshold>0說明調用了HashMap(initialCapacity)和HashMap(initialCapacity, loadFactor)構造器
    else if (oldThr > 0)
        newCap = oldThr;//新容量設為數組門檻值
    else { //3、若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 的碰撞率可能會比較高，進而導緻連結清單長度較長。這個時候應該優先擴容，而不是立馬樹化。

紅黑樹拆分

拆分就是指擴容後對元素重新映射時，紅黑樹可能會被拆分成兩條連結清單。

由于篇幅有限，有關紅黑樹這裡就不展開了。

查找

在看源碼之前先來簡單梳理一下查找流程：

首先通過自定義的hash方法計算出key的hash值，求出在數組中的位置
判斷該位置上是否有節點，若沒有則傳回null，代表查詢不到指定的元素
若有則判斷該節點是不是要查找的元素，若是則傳回該節點
若不是則判斷節點的類型，如果是紅黑樹的話，則調用紅黑樹的方法去查找元素
如果是連結清單類型，則周遊連結清單調用equals方法去查找元素

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) {
        //基本類型用==比較，其它用equals比較
        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（相當于對數組長度取模，這裡用位運算進行了優化），這點在上面已經說過了，就不再廢話了。

插入

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

當table數組為空時，通過擴容的方式初始化table
通過計算鍵的hash值求出下标後，若該位置上沒有元素(沒有發生hash沖突)，則建立Node節點插入
若發生了hash沖突，周遊連結清單查找要插入的key是否已經存在，存在的話根據條件判斷是否用新值替換舊值
如果不存在，則将元素插傳入連結表尾部，并根據連結清單長度決定是否将連結清單轉為紅黑樹
判斷鍵值對數量是否大于門檻值，大于的話則進行擴容操作

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

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方法後才進行初始化的。

這裡還有一個知識點就是在JDK1.8版本HashMap是在連結清單尾部插入元素的，而在1.7版本裡是插傳入連結表頭部的，1.7版本這麼設計的原因可能是作者認為新插入的元素使用到的頻率會比較高，插入頭部的話可以減少周遊次數。

那為什麼1.8改成尾插法了呢？主要是因為頭插法在多線程環境下可能會導緻兩個節點互相引用，形成死循環，由于此文主要講解1.8版本，感興趣的小夥伴可以去看看1.7版本的源碼。

删除

HashMap的删除操作并不複雜，僅需三個步驟即可完成。

定位桶位置
周遊連結清單找到相等的節點
第三步删除節點

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;
    //1、定位元素桶位置
    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 {
                // 2、周遊連結清單，找到待删除節點
                do {
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }        
        // 3、删除節點，并修複連結清單或紅黑樹
        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的key有什麼限制嗎？相信很多人都知道HashMap的key需要重寫equals和hashcode方法。

為什麼HashMap的key需要重寫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的線程安全問題，希望本篇文章能幫助到大家，同時也歡迎讨論指正，謝謝支援！

一文看懂HashMap面試考點

資料結構

table數組長度永遠為2的幂次方

那麼為什麼要把數組長度設計為2的幂次方呢？

擴容

連結清單樹化

紅黑樹拆分

查找

插入

删除

周遊

equasl和hashcode

繼續閱讀

資料結構與算法（27）——排序（二）

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

Dijkstra--簡易版（最短路徑）

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

hdu7108哈希