問：“你用過HashMap，你能跟我說說它嗎？”

“當然用過，HashMap是一種<key,value>的存儲結構，能夠快速將key的數據put方式存儲起來，然後很快的通過get取出來”，然後說“HashMap不是線程安全的， 答：

HashTable是線程安全的，通過synchronized實現的。HashMap取值非常快”等等。這個時候說明他已經很熟練使用HashMap的工具了。

問：“你知道HashMap 在put和get的時候是怎麽工作的嗎？”

答：“HashMap是通過key計算出Hash值，然後將這個Hash值映射到對象的引用上，get的時候先計算key的hash值，然後找到對象”。這個時候已經顯得不自信了。

問：“HashMap的key為什麽一般用字符串比較多，能用其他對象，或者自定義的對象嗎？為什麽？”

答：“這個沒研究過，一般習慣用String。”

問：“你剛才提到HashMap不是線程安全的，你怎麽理解線程安全。原理是什麽？幾種方式避免線程安全的問題。”

答：“線程安全就是多個線程去訪問的時候，會對對象造成不是預期的結果，一般要加鎖才能線程安全。”

HashMap的面試問題能夠考察面試者的線程問題、Java內存模型問題、線程可見與不可變問題、Hash計算問題、鏈表結構問題、二進制的&、|、<<、>>等問題。所以一個HashMap就能考驗一個人的技術功底了。

一、數據結構

HashMap是數組+鏈表+紅黑樹（JDK1.8增加了紅黑樹部分）實現的，如下圖所示

// Node<K,V> 類用來實現數組及鏈表的數據結構　 static class Node<K,V> implements Map.Entry<K,V> {        final int hash; //保存節點的 hash　值
        final K key; //保存節點的　key　值
        V value;　//保存節點的　value 值
        Node<K,V> next;　//指向鏈表結構下的當前節點的　next 節點，紅黑樹　TreeNode　節點中也有用到

        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()        { }        public final V getValue()      { }        public final String toString() { }        public final int hashCode() { }        public final V setValue(V newValue) { }        public final boolean equals(Object o) { }
    }    
    public class LinkedHashMap<K,V> {          static class Entry<K,V> extends HashMap.Node<K,V> {
                Entry<K,V> before, after;
                Entry(int hash, K key, V value, Node<K,V> next) {                    super(hash, key, value, next);
                }    
          }
    }    
    
　// TreeNode<K,V> 繼承 LinkedHashMap.Entry<K,V>，用來實現紅黑樹相關的存儲結構
    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // 存儲當前節點的父節點
        TreeNode<K,V> left;　//存儲當前節點的左孩子
        TreeNode<K,V> right;　//存儲當前節點的右孩子
        TreeNode<K,V> prev;    // 存儲當前節點的前一個節點
        boolean red;　// 存儲當前節點的顏色（紅、黑）
        TreeNode(int hash, K key, V val, Node<K,V> next) {            super(hash, key, val, next);
        }       
        final TreeNode<K,V> root() { }      
        static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) { }      
        final TreeNode<K,V> find(int h, Object k, Class<?> kc) { }     
        final void treeify(Node<K,V>[] tab) { }     
        final Node<K,V> untreeify(HashMap<K,V> map) { }       
        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,int h, K k, V v) { }        
        final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab, boolean movable) { }        final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) { }        /* ------------------------------------------------------------ */
        // Red-black tree methods, all adapted from CLR
        // 紅黑樹相關操作
        static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,TreeNode<K,V> p) {}        static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,TreeNode<K,V> p) { }        static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root, TreeNode<K,V> x) {}        static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,TreeNode<K,V> x) {}       

        static <K,V> boolean checkInvariants(TreeNode<K,V> t) {}

    }

二、成員屬性

//創建 HashMap 時未指定初始容量情況下的默認容量   
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

　  //HashMap 的最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;    //HashMap 默認的裝載因子,當 HashMap 中元素數量超過 容量*裝載因子 時，進行　resize()　操作
    static final float DEFAULT_LOAD_FACTOR = 0.75f;    //用來確定何時將解決 hash 沖突的鏈表轉變為紅黑樹
    static final int TREEIFY_THRESHOLD = 8;    // 用來確定何時將解決 hash 沖突的紅黑樹轉變為鏈表
    static final int UNTREEIFY_THRESHOLD = 6; 
    /* 當需要將解決 hash 沖突的鏈表轉變為紅黑樹時，需要判斷下此時數組容量，若是由於數組容量太小（小於　MIN_TREEIFY_CAPACITY　）導致的 hash 沖突太多，則不進行鏈表轉變為紅黑樹操作，轉為利用　resize() 函數對　hashMap 擴容　*/
    static final int MIN_TREEIFY_CAPACITY = 64;    //保存Node<K,V>節點的數組
    transient Node<K,V>[] table;    //由　hashMap 中 Node<K,V>　節點構成的 set
    transient Set<Map.Entry<K,V>> entrySet;    //記錄 hashMap 當前存儲的元素的數量
    transient int size;    //記錄　hashMap 發生結構性變化的次數（註意　value 的覆蓋不屬於結構性變化）
    transient int modCount;    //threshold的值應等於 table.length * loadFactor, size 超過這個值時進行　resize()擴容
    int threshold;    //記錄 hashMap 裝載因子
    final float loadFactor;

1、loadFactor參數

如果內存富余，那麽建議把loadFactor設置的小一點，但是要註意初始size的設置，如果不合適會導致頻繁的 resize 嚴重影響插入的效率。

如果內存比較吃緊，就可以把loadFactor設置的大一些，但是loadFactor設置大的話，鍵值對以鏈表的形式存儲的概率就提高，平均的查詢時間變慢，但是對於插入而言，雖然沒有直接的影響，但是loadFactor提高，

三、構造方法

//構造方法１，指定初始容量及裝載因子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;
    　/* tableSizeFor(initialCapacity)　方法返回的值是最接近 initialCapacity 的2的冪，若指定初始容量為９，則實際 hashMap 容量為16*/
    　//註意此種方法創建的 hashMap 初始容量的值存在　threshold 中
        this.threshold = tableSizeFor(initialCapacity);
}//tableSizeFor(initialCapacity)　方法返回的值是最接近 initialCapacity 的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;
}//構造方法２，僅指定初始容量，裝載因子的值采用默認的　0.75public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);
}//構造方法３，所有參數均采用默認值public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}

四、put方法

當我們往HashMap中put元素的時候，先根據key的hashCode重新計算hash值，根據hash值得到這個元素在數組中的位置（即下標），如果數組該位置上已經存放有其他元素了，那麽在這個位置上的元素將以鏈表的形式存放，新加入的放在鏈頭，最先加入的放在鏈尾，數組中存儲的是最後插入的元素 。如果數組該位置上沒有元素，就直接將該元素放到此數組中的該位置上。

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,  　　　　　　　　//這裏onlyIfAbsent表示只有在該key對應原來的value為null的時候才插入，也就是說如果value之前存在了，就不會被新put的元素覆蓋。
                   boolean evict) {                                              //evict參數用於LinkedHashMap中的尾部操作，這裏沒有實際意義。
        Node<K,V>[] tab; Node<K,V> p; int n, i;　　　　　　　　　　　　　　　　　　　　//定義變量tab是將要操作的Node數組引用，p表示tab上的某Node節點，n為tab的長度，i為tab的下標。
        if ((tab = table) == null || (n = tab.length) == 0)　　　                 //判斷當table為null或者tab的長度為0時，即table尚未初始化，此時通過resize()方法得到初始化的table。             　　　　　　　　　　　
            n = (tab = resize()).length;　　　　　　　　　　　　　　　　　　　　　　　　//這種情況是可能發生的，HashMap的註釋中提到：The table, initialized on first use, and resized as necessary。
        if ((p = tab[i = (n - 1) & hash]) == null)                               //此處通過（n - 1） & hash 計算出的值作為tab的下標i，並另p表示tab[i]，也就是該鏈表第一個節點的位置。並判斷p是否為null。
            tab[i] = newNode(hash, key, value, null);　　　　　　　　　　　　　　　　 //當p為null時，表明tab[i]上沒有任何元素，那麽接下來就new第一個Node節點，調用newNode方法返回新節點賦值給tab[i]。
        else {　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　                //下面進入p不為null的情況，有三種情況：p為鏈表節點；p為紅黑樹節點；p是鏈表節點但長度為臨界長度TREEIFY_THRESHOLD，再插入任何元素就要變成紅黑樹了。
            Node<K,V> e; K k;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //定義e引用即將插入的Node節點，並且下文可以看出 k = p.key。
            if (p.hash == hash &&　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //HashMap中判斷key相同的條件是key的hash相同，並且符合equals方法。這裏判斷了p.key是否和插入的key相等，如果相等，則將p的引用賦給e。
                ((k = p.key) == key || (key != null && key.equals(k))))           //這一步的判斷其實是屬於一種特殊情況，即HashMap中已經存在了key，於是插入操作就不需要了，只要把原來的value覆蓋就可以了。
                e = p;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  //這裏為什麽要把p賦值給e，而不是直接覆蓋原值呢？答案很簡單，現在我們只判斷了第一個節點，後面還可能出現key相同，所以需要在最後一並處理。
            else if (p instanceof TreeNode)                                       //現在開始了第一種情況，p是紅黑樹節點，那麽肯定插入後仍然是紅黑樹節點，所以我們直接強制轉型p後調用TreeNode.putTreeVal方法，返回的引用賦給e。
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);   //你可能好奇，這裏怎麽不遍歷tree看看有沒有key相同的節點呢？其實，putTreeVal內部進行了遍歷，存在相同hash時返回被覆蓋的TreeNode，否則返回null。
            else {　　　　　　　　　　　　       　　　　　　　　                       //接下裏就是p為鏈表節點的情形，也就是上述說的另外兩類情況：插入後還是鏈表/插入後轉紅黑樹。另外，上行轉型代碼也說明了TreeNode是Node的一個子類。
                for (int binCount = 0; ; ++binCount) {　　　　　　　　　　　　　　　　 //我們需要一個計數器來計算當前鏈表的元素個數，並遍歷鏈表，binCount就是這個計數器。
                    if ((e = p.next) == null) {　　　　　　　　　　　　　　　　　　　　 //遍歷過程中當發現p.next為null時，說明鏈表到頭了，直接在p的後面插入新的鏈表節點，即把新節點的引用賦給p.next，插入操作就完成了。註意此時e賦給p。
                        p.next = newNode(hash, key, value, null);　　　　　　　　　　//最後一個參數為新節點的next，這裏傳入null，保證了新節點繼續為該鏈表的末端。
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 　　  //插入成功後，要判斷是否需要轉換為紅黑樹，因為插入後鏈表長度加1，而binCount並不包含新節點，所以判斷時要將臨界閾值減1。
                            treeifyBin(tab, hash);　　　　　　　　　　　　　　　　     //當新長度滿足轉換條件時，調用treeifyBin方法，將該鏈表轉換為紅黑樹。
                        break;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　   //當然如果不滿足轉換條件，那麽插入數據後結構也無需變動，所有插入操作也到此結束了，break退出即可。
                    }                    if (e.hash == hash &&　　　　　　　　　　　　　　　　　　　　　　　　 //在遍歷鏈表的過程中，我之前提到了，有可能遍歷到與插入的key相同的節點，此時只要將這個節點引用賦值給e，最後通過e去把新的value覆蓋掉就可以了。
                        ((k = e.key) == key || (key != null && key.equals(k))))　　 //老樣子判斷當前遍歷的節點的key是否相同。
                        break;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  //找到了相同key的節點，那麽插入操作也不需要了，直接break退出循環進行最後的value覆蓋操作。
                    p = e;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //在第21行我提到過，e是當前遍歷的節點p的下一個節點，p = e 就是依次遍歷鏈表的核心語句。每次循環時p都是下一個node節點。
                }
            }            if (e != null) { // existing mapping for key　　　　　　　　　　　　　　　　//左邊註釋為jdk自帶註釋，說的很明白了，針對已經存在key的情況做處理。
                V oldValue = e.value;　　　　　　　　　　　　　　　　　　　　　　　　　　　//定義oldValue，即原存在的節點e的value值。
                if (!onlyIfAbsent || oldValue == null)　　　　　　　　　　　　　　　　　//前面提到，onlyIfAbsent表示存在key相同時不做覆蓋處理，這裏作為判斷條件，可以看出當onlyIfAbsent為false或者oldValue為null時，進行覆蓋操作。
                    e.value = value;　　　　　　　　　　　　　　　　　　　　　　　　      //覆蓋操作，將原節點e上的value設置為插入的新value。
                afterNodeAccess(e);　　　　　　　　　　　　　　　　　　　　　　　　　　　　//這個函數在hashmap中沒有任何操作，是個空函數，他存在主要是為了linkedHashMap的一些後續處理工作。
                return oldValue;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//這裏很有意思，他返回的是被覆蓋的oldValue。我們在使用put方法時很少用他的返回值，甚至忘了它的存在，這裏我們知道，他返回的是被覆蓋的oldValue。
            }
        }　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 
        ++modCount;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //收尾工作，值得一提的是，對key相同而覆蓋oldValue的情況，在前面已經return，不會執行這裏，所以那一類情況不算數據結構變化，並不改變modCount值。
        if (++size > threshold)　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //同理，覆蓋oldValue時顯然沒有新元素添加，除此之外都新增了一個元素，這裏++size並與threshold判斷是否達到了擴容標準。
            resize();　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //當HashMap中存在的node節點大於threshold時，hashmap進行擴容。
        afterNodeInsertion(evict);　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//這裏與前面的afterNodeAccess同理，是用於linkedHashMap的尾部操作，HashMap中並無實際意義。1
        return null;　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　   　　　    //最終，對於真正進行插入元素的情況，put函數一律返回null。
    }

①.判斷鍵值對數組table[i]是否為空或為null，否則執行resize()進行擴容；

②.根據鍵值key計算hash值得到插入的數組索引i，如果table[i]==null，直接新建節點添加，轉向⑥，如果table[i]不為空，轉向③；

③.判斷table[i]的首個元素是否和key一樣，如果相同直接覆蓋value，否則轉向④，這裏的相同指的是hashCode以及equals；

④.判斷table[i] 是否為treeNode，即table[i] 是否是紅黑樹，如果是紅黑樹，則直接在樹中插入鍵值對，否則轉向⑤；

⑤.遍歷table[i]，判斷鏈表長度是否大於8，大於8的話把鏈表轉換為紅黑樹，在紅黑樹中執行插入操作，否則進行鏈表的插入操作；遍歷過程中若發現key已經存在直接覆蓋value即可；

⑥.插入成功後，判斷實際存在的鍵值對數量size是否超多了最大容量threshold，如果超過，進行擴容。

resize方法

// Initializes or doubles table size，兩倍擴容並初始化table  final Node<K,V>[] resize() {  
        Node<K,V>[] oldTab = table;  
        int oldCap = (oldTab == null) ? 0 : oldTab.length;  
        int oldThr = threshold;  
        int newCap, newThr = 0; // 新容量，新閥值  
        if (oldCap > 0) {  
            if (oldCap >= MAXIMUM_CAPACITY) {  
                threshold = Integer.MAX_VALUE;  
                return oldTab; //到達極限，無法擴容  
            }  
            else if((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&  
                     oldCap >= DEFAULT_INITIAL_CAPACITY)  
                newThr = oldThr << 1; // double threshold閥值  
       }  
      // oldCap=0 ,oldThr>0，threshold(新的擴容resize臨界值)  
       else if (oldThr > 0)   
           newCap = oldThr; //新容量=舊閥值（擴容臨界值）  
       else {     // oldCap=0 ,oldThr=0，調用默認值來初始化  
         newCap = DEFAULT_INITIAL_CAPACITY;  
         newThr=(int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);  
        }  
        if (newThr== 0) { //新閥值為0，則需要計算新的閥值   
           float ft = (float)newCap * loadFactor;  
           newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);  
        }  
        threshold = newThr; //設置新的閥值  
        @SuppressWarnings({"rawtypes","unchecked"})  
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //創建新的桶  
        table = newTab;   
         // table初始化,bucket copy到新bucket，分鏈表和紅黑樹  
        if (oldTab != null) { // 不為空則挨個copy，影響效率！！！  
            for (int j = 0; j < oldCap; ++j) {  
               Node<K,V> e;  
               if ((e = oldTab[j]) != null) { //先賦值再判斷  
                  oldTab[j] = null; //置null，主動GC  
                  //如果該桶只有一個元素，重新計算桶位，則直接賦到新的桶裏面  
                  if (e.next == null)   
                //1.6的indexFor，計算key;tableSizeFor性能優化  
                    newTab[e.hash &(newCap - 1)]= e; //hash&(length-1)  
                  else if (e instanceof TreeNode) // 紅黑樹  
                     ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);  
                  else { //鏈表，preserve order保持順序  
                        //一個桶中有多個元素，遍歷將它們移到新的bucket或原bucket  
                        Node<K,V> loHead = null,loTail = null;//lo原bucket的鏈表指針  
                        Node<K,V> hiHead = null, hiTail = null;//hi新bucket的鏈表指針  
                        Node<K,V> next;  
                        do {  
                            next = e.next;  
                            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) { //原bucket位置的尾指針不為空(即還有node)  
                            loTail.next = null; //鏈表最後得有個null  
                            newTab[j] = loHead;//鏈表頭指針放在新桶的相同下標(j)處  
                        }  
                        if (hiTail != null) {  //放在桶 j+oldCap  
                            hiTail.next = null;  
                            newTab[j + oldCap] = hiHead;//j+oldCap見下  
                        }  
                    }  
                }  
            }  
        }  
        return newTab;  
    }

treeifyBin方法

// 轉化為樹節點
    final void treeifyBin(Node<K,V>[] tab, int hash) {
        /*int n, index; Node<K,V> e;
        // 如果hash為空，或者鍵值對總數不夠，則擴容        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();        // 加入的node不為空
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            // 該循環把原本的單向鏈表，改成使用紅黑樹節點鏈接的雙向鏈表            do {                // 單向鏈表節點轉化為紅黑樹節點
                TreeNode<K,V> p = replacementTreeNode(e, null);
                // 此處類似構造一個雙向鏈表                if (tl == null)                    // hd為頭節點
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            // 遍歷單向鏈表
            } while ((e = e.next) != null);            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }*/
    }

五、get方法

public V get(Object key) {
        Node<K,V> e;        return (e = getNode(hash(key), key)) == null ? null : e.value;　　　　　　//根據key及其hash值查詢node節點，如果存在，則返回該節點的value值。
    }    final Node<K,V> getNode(int hash, Object key) {　　　　　　　　　　　　　　　　  //根據key搜索節點的方法。記住判斷key相等的條件：hash值相同 並且 符合equals方法。
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;        if ((tab = table) != null && (n = tab.length) > 0 &&　　　　　　　　　　　　//根據輸入的hash值，可以直接計算出對應的下標（n - 1）& hash，縮小查詢範圍，如果存在結果，則必定在table的這個位置上。
            (first = tab[(n - 1) & hash]) != null) {            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))　　　 //判斷第一個存在的節點的key是否和查詢的key相等。如果相等，直接返回該節點。
                return first;            if ((e = first.next) != null) {　　　　　　　　　　　　　　　　　　　　　　 //遍歷該鏈表/紅黑樹直到next為null。
                if (first instanceof TreeNode)　　　　　　　　　　　　　　　　　　     //當這個table節點上存儲的是紅黑樹結構時，在根節點first上調用getTreeNode方法，在內部遍歷紅黑樹節點，查看是否有匹配的TreeNode。
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);                do {                    if (e.hash == hash &&　　　　　　　　　　　　　　　　　　　　　　　　//當這個table節點上存儲的是鏈表結構時，用跟第11行同樣的方式去判斷key是否相同。
                        ((k = e.key) == key || (key != null && key.equals(k))))                        return e;
                } while ((e = e.next) != null);　　　　　　　　　　　　　　　　　　  　 //如果key不同，一直遍歷下去直到鏈表盡頭，e.next == null。
            }
        }        return null;
    }    final TreeNode<K,V> getTreeNode(int h, Object k) {
　　　　　　　　//從根節點開始，調用 find 方法進行查找
            return ((parent != null) ? root() : this).find(h, k, null);
        }
　        final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
            TreeNode<K,V> p = this;            do {
                int ph, dir; K pk;
                TreeNode<K,V> pl = p.left, pr = p.right, q;
　　　　　　　　　//首先進行hash 值的比較，若不同令當前節點變為它的左孩子或者右孩子
                if ((ph = p.hash) > h)
                    p = pl;                else if (ph < h)
                    p = pr;
　　　　　　　　　//hash 值相同，進行 key　值的比較 
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))                    return p;                else if (pl == null)
                    p = pr;                else if (pr == null)
                    p = pl;
　　　　　　　　　//執行到這兒，意味著hash 值相同，key 值不同 
   　　　　　　　　//若k 是可比較的並且k.compareTo(pk) 返回結果不為０可進入下面elseif   
                else if ((kc != null ||
                          (kc = comparableClassFor(k)) != null) &&
                         (dir = compareComparables(kc, k, pk)) != 0)
                    p = (dir < 0) ? pl : pr;/*若 k 是不可比較的　或者　k.compareTo(pk) 返回結果為０則在整棵樹中進行查找，先找右子樹，右子樹沒有再找左子樹*/
                else if ((q = pr.find(h, k, kc)) != null)                    return q;                else
                    p = pl;
            } while (p != null);            return null;
        }

六、remove方法

final Node<K,V> removeNode(int hash, Object key, Object value,                               boolean matchValue, boolean movable) {        // 與get的邏輯一樣
        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;            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;            else if ((e = p.next) != null) {                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;
    }

七、源碼總結

源碼分析是一種臨界知識，掌握了這種臨界知識，能不變應萬變，源碼分析對於很多人來說很枯燥，生澀難懂。

源碼閱讀，我覺得最核心有三點：技術基礎+強烈的求知欲+耐心。

我認為是閱讀源碼的最核心驅動力。我見到絕大多數程序員，對學習的態度，基本上就是這幾個層次(很偏激哦)：

1. 只關註項目本身，不懂就baidu一下。

2. 除了做好項目，還會閱讀和項目有關的技術書籍，看wikipedia。

3. 除了閱讀和項目相關的書外，還會閱讀IT行業的書，比如學Java時，還會去了解函數語言，如LISP。

4. 找一些開源項目看看，大量試用第三方框架，還會寫寫demo。

5. 閱讀基礎框架、J2EE規範、Debug服務器內核。

大多數程序都是第1種，到第5種不光需要濃厚的興趣，還需要勇氣：我能讀懂嗎？其實，你能夠讀懂的。

耐心，真的很重要。因為你極少看到閱讀源碼的指導性文章或書籍，也沒有人要求或建議你讀。你讀的過程中經常會卡住，而一卡主可能就陷進了迷宮。這時，你需要做的，可能是暫時中斷一下，再從外圍看看它：如API結構、框架的設計圖。

下圖是我總結出來的目前最應該學習的源碼知識點：

在這裏順便給大家推薦一個交流學習群：650385180，裏面會分享一些資深架構師錄制的視頻錄像：有Spring，MyBatis，Netty源碼分析，高並發、高性能、分布式、微服務架構的原理，JVM性能優化這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多，相信對於已經工作和遇到技術瓶頸的碼友，在這個群裏一定有你需要的內容。

參考文獻：

http://www.cnblogs.com/jzb-blog/p/6637823.html

https://www.cnblogs.com/wuhuangdi/p/4175991.html

https://www.cnblogs.com/Michaelwjw/p/6411176.html

https://blog.csdn.net/u013140391/article/details/72066906

高級架構進階之HashMap源碼就該這麽學