JDK 1.8 HashMap 源碼分析(一)

空閑時間，根了一下最新HashMap源碼，這里記錄一下。如有錯漏，請指正。

篇幅太長，因此這里分了兩篇文章。

主要從以下功能切入：

  • 構造函數
  • put
  • get
  • remove

構造函數：

//默認構造函數,默認初始容量為16 ，默認加載因子為0.75
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

//指定初始容量的構造函數，默認加載因子為0.75
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//指定初始容量和加載因子的構造函數
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    //若初始容量大于最大容量，則初始容量為最大容量
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    
    //若加載因子小于0或NaN即Not a number(0.0f/0.0f的值就是NaN)的話，拋出異常
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    //初始化閾值，該值用于判斷何時需要擴容(resize)
    this.threshold = tableSizeFor(initialCapacity);
}


/**
* 該方法用于保證數組長度為2的n次方
* 
* 問: 為何數組長度一定要為2的n次方？
* 我們知道2的n次方=1+n個0，而2的n次方-1  實際就是n個1
* 在HashMap中，我們需要根據key的hash值取數組中的下標，為了較少碰撞（即key在table中位置相同），每個key在數 * 組中的下標可以通過以下公式獲?。?* int index = key.hash % table.length;
* 但是由于%運算效率不高，因此使用效率高的與運算來取代%運算
* int index =  (table.length - 1) & key.hash; 
* 這里又要回到為什么要保證數組長度為2的n次方，因為2的n次方-1=n個1，例如這里數組長度為2?=16，那么：
* int index = 1111 & key.hash; 
* 這樣既保證了均勻性，index也不會超過數組長度，同時效率也提高了。
* 兩種運算效率的對比可自行測試。
* */
static final int tableSizeFor(int cap) {
    //>>> : 無符號右移，忽略符號位，空位都以0補齊，即這里保證數組長度為正數
    //>> ：帶符號右移，正數右移高位補0，負數右移高位補1
    
    //以下運算為何可以保證返回值為2的n次方呢？
    //我們隨便拿個數字cap=190，那么n = 189，二進制為：10111101
    //10111101 |= 01011110 結果為： 11111111 = 2的8次方-1
    //接著后面的|=已經無需在意，因此這里189的二進制所有位都為1了
    //最后返回值為n+1即2的8次方 = 256
    //經上面例子得出結果：通過將cap-1的二進制最高位1后所有位都轉為1，最后再加上1就是我們想要的2的n次方了
    
    //這里再詳細說一下下面算法：
    int n = cap - 1;
        n |= n >>> 1; //將最高位后1位 置為1
        n |= n >>> 2; //將最高位后2位 置為1
        n |= n >>> 4; //由于已經將前4位置為1了，這時n>>>4用于轉后4位
        n |= n >>> 8; //由于已經將前8位置為1了，這時n>>>8用于轉后8位
        n |= n >>> 16; //由于已經將前16位置為1了，這時n>>>16用于轉后16位
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

//根據指定map構造一個新的HashMap，默認加載因子為0.75
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

//將map內容拷貝到本地HashMap，關于evict參數，HashMap中用于判斷數組是否處于創建模式
//evict = false的話，處于創建模式
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size(); //獲取map大小
    if (s > 0) {  //map 非空
        if (table == null) { //若當前數組為空，根據map大小獲取數組閾值
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        else if (s > threshold) //否則當前數組為空且map大小比閾值大，需要擴容才能放得下map
            resize(); //關于擴容函數，后面會分析
        //處理好數組號，將map的所有值都拷貝到HashMap
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict);
        }
    }
}

put相關函數

//對外接口，put一個key-value
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

//根據傳遞的key對象獲取hash值
static final int hash(Object key) {
    //我們上面說過，要盡可能減少碰撞(不同key在數組中處于相同位置)，保證均勻性以滿足散列特征。
    int h;
    //key的hash值的高16位不變，低16位與高16位異或作為key的最終hash值
    //我們前面知道數組長度總是為2的n次方，并且最后根據key的hash值取數組下標的時候公式為:
    //int index = (table.length - 1) & hash;
    //假如key.hashCode() = 1111-0001-1111-1111-0111-1110-1111-1000，數組長度為2?=16=0001-0110
    //最高的24位都沒有參與運算，因為數組長度的限制(我們事實也很難會用到2^30這個最大容量)。因此，
    //大多數情況下hash值的高位都沒有參與運算(例子這里只有低5位參與運算)，這樣的話很容易產生碰撞，
    //因此設計者通過將高16位與低16位異或來減少這種影響
    //更詳細說明可參考:https://www.cnblogs.com/zhengwang/p/8136164.html
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}


//內部實現類，put一個key-value
//hash:key的哈希值
//key: key值
//value: value值
//onlyIfAbsent: true的話，不改變原本已經存在的key-value
//evict: 關于evict參數，evict = false的話，table處于創建模式
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    
     //若數組為空或者數組長度為0則擴容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length; 
    
    //根據hash獲取數組中的下標，若數組中不存在節點的話，new一個節點并放到對應數組下標
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    
    //若數組中已經存在節點，當前節點為tab[(n - 1) & hash]
    else { 
        Node<K,V> e; K k;
        //若當前節點與要插入的key-value的key相等的話，將e賦值為當前節點p
        //這里的key相等為以下判斷，即要插入的key-value的key的hash值與當前節點的hash值相等
        //且k=當前節點的key與key相等或要插入的key-value的key.equals(k)為true。
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        
        //若當前節點為紅黑樹節點的話，e=紅黑樹節點的putTreeVal方法的返回值
        //putTreeVal后面會細講
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        
        //下面代碼表示循環鏈表，找出鏈表與要插入的key-value的key相等的節點
        else {
            for (int binCount = 0; ; ++binCount) {
                //若在鏈表中沒有找到對應key(最后節點.next為null)的節點，跳出循環
                if ((e = p.next) == null) {
                    //new一個節點，并插到鏈表最后面
                    p.next = newNode(hash, key, value, null);
                    
                    //判斷當前鏈表長度是否比紅黑樹定義的閾值大，是的話，則開始將鏈表節點轉化為紅黑樹節點
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                
                //若在鏈表中找到了與要插入的key-value的key相等的節點，跳出循環
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                
                //將next賦給當前節點，用于循環
                p = e;
            }
        }
        
        //在鏈表中找到了與要插入的key-value的key相等的節點，例如，相同一個key就會有相同的節點
        if (e != null) { 
            V oldValue = e.value;
            //判斷onlyIfAbsent=false或原本key-value的值為空的時候則賦為最新值
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e); //LinkedHashMap后期操作函數，HashMap暫未實現
            return oldValue; //返回舊的值
        }
    }
    
    ++modCount; //增加修改次數
    
    //判斷是否需要擴容
    if (++size > threshold)
        resize();
    
    afterNodeInsertion(evict);//LinkedHashMap后期操作函數，HashMap暫未實現
    return null;
}

//將鏈表節點轉化為紅黑樹節點
//tab: 鏈表節點數組
//hash: 當前要插入key的hash值
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    
    //若tab為null或數組長度小于紅黑樹的最小容量的話，沒有必要將鏈表轉為紅黑樹，直接擴容
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    
    //e = tab[index = (n - 1) & hash]) 取數組中的節點即鏈表中的第一個節點
    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 = p; //記錄紅黑樹頭節點即鏈表中第一個節點
            else {
                //新增一個雙向鏈表
                p.prev = tl; //設置當前節點的前一個節點
                tl.next = p; //設置上一個節點的后一個節點
            }
            tl = p; //將上一個節點賦值為當前節點，用于循環，直到鏈表最后一個
        } while ((e = e.next) != null);
        
        //若頭節點非空，則從紅黑樹頭節點開始將鏈表轉化為紅黑樹結構
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

//從當前節點開始將鏈表節點轉化為紅黑樹數據結構
final void treeify(Node<K,V>[] tab) {
    TreeNode<K,V> root = null; //根節點
    //從當前節點開始，進行結構轉換
    //x為當前鏈表節點
    for (TreeNode<K,V> x = this, next; x != null; x = next) {
        //獲取當前節點的后一個節點
        next = (TreeNode<K,V>)x.next;
        x.left = x.right = null; //設置左右節點為null
        
        //若根節點為空，則將當前節點設置為根節點
        //并且parent設置為null，因為根節點沒有父節點
        //并且根節點一定為黑色
        if (root == null) {
            x.parent = null;
            x.red = false;
            root = x;
        }
        
        //若根節點非空
        else {
            K k = x.key; //當前鏈表節點的key
            int h = x.hash; //當前鏈表節點的hash值
            Class<?> kc = null; //聲明key的class
            
            //從根節點開始進行構成紅黑樹結構
            for (TreeNode<K,V> p = root;;) {
                int dir, ph; //聲明方向，當前節點hash值
                K pk = p.key; //聲明當前節點的key
                
                //若當前紅黑樹節點的hash比鏈表節點的hash值大的話，則將鏈表節點放在紅黑樹節點的左邊
                if ((ph = p.hash) > h)
                    dir = -1; 
                //若當前紅黑樹節點的hash比鏈表節點的hash值小的話，則將鏈表節點放在紅黑樹節點的右邊
                else if (ph < h)
                    dir = 1;
                
                //若當前紅黑樹節點的hash與鏈表節點的hash值相等的話需要再進行判斷(即判斷兩個key是否相同)
                //若kc為null并且當前鏈表節點的key的class沒有實現comparable接口
                //或者kc不為null并且當前鏈表節點的key的class實現了comparable，則通過比較得出方向
                //否則將調用tieBreakOrder(k, pk)獲取一個必定為左或右的方向
                else if ((kc == null && (kc = comparableClassFor(k)) == null) 
                         || (dir = compareComparables(kc, k, pk)) == 0)
                    dir = tieBreakOrder(k, pk);

                //聲明xp=當前紅黑樹節點
                TreeNode<K,V> xp = p;
                //根據方向獲取當前紅黑樹節點的左節點或右節點
                //若為空的話，則將當前鏈表節點x插入到當前紅黑樹節點的左邊或右邊并且退出循環
                //否則繼續循環
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    x.parent = xp; //設置當前鏈表節點的父節點為當前紅黑樹節點
                    
                    if (dir <= 0) 
                        xp.left = x; //當前鏈表節點x為當前紅黑樹節點的左節點
                    else
                        xp.right = x; //當前鏈表節點x為當前紅黑樹節點的右節點
                    
                    //插入后需要調整紅黑樹平衡，并且將平衡后返回的節點作為根節點
                    root = balanceInsertion(root, x); 
                    break;
                }
            }
        }
    }
    
    moveRootToFront(tab, root);
}

//根據對象獲取實現Comparable的接口類
static Class<?> comparableClassFor(Object x) {
    //implement Comparable接口
    if (x instanceof Comparable) {
        Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
        
        //若class為String.class的話則直接返回，因為String已實現Comparable<String>接口
        if ((c = x.getClass()) == String.class) // bypass checks
            return c;
        
        //獲取class實現的接口
        if ((ts = c.getGenericInterfaces()) != null) {
            for (int i = 0; i < ts.length; ++i) {
                //遍歷所有接口
                //判斷是否繼承Comparable接口
                if (((t = ts[i]) instanceof ParameterizedType) &&
                    ((p = (ParameterizedType)t).getRawType() ==
                     Comparable.class) &&
                    (as = p.getActualTypeArguments()) != null &&
                    as.length == 1 && as[0] == c) 
                    //是的話直接返回class
                    return c;
            }
        }
    }
    return null;
}

//根據class比較兩個對象
static int compareComparables(Class<?> kc, Object k, Object x) {
    return (x == null || x.getClass() != kc ? 0 :
            ((Comparable)k).compareTo(x));
}

//該方法一定會返回一個要么為1，要么為-1的值
//若a為null, 或者b為null，或者a的class name和b的class name相等
//則直接返回a和b的System.identityHashCode值相比較，若還是一樣的話，則返回-1
//否則返回1
static int tieBreakOrder(Object a, Object b) {
    int d;
    if (a == null || b == null ||
        (d = a.getClass().getName().
         compareTo(b.getClass().getName())) == 0)
        d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
             -1 : 1);
    return d;
}

//插入一個key-value后需要重新調整紅黑樹結構，使其達到平衡，即保證log(n)的時間復雜度
//root: 根節點
//x：要插入的紅黑樹節點
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                            TreeNode<K,V> x) {
    x.red = true; //紅黑樹規則：新插入的節點顏色總是紅色的
    
    //聲明
    //xp: 要插入節點的父節點
    //xpp: 要插入節點的爺爺節點
    //xppl: 要插入節點的爺爺節點的左節點
    //xppr：要插入節點的爺爺節點的右節點
    for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
        //若父節點為null，則當前要插入的節點x為根節點
        //將根節點置為黑色，返回當前要插入的節點x
        if ((xp = x.parent) == null) {
            x.red = false;
            return x;
        }
        
        //若父節點為黑色或者父節點的父節點為null的話，返回根節點
        //因為當前父節點即為根節點，且x節點為紅色，沒有違反紅黑樹規則
        else if (!xp.red || (xpp = xp.parent) == null)
            return root;
        
        //往下執行： 父節點為紅色 
        //若父節點為爺爺節點的左節點
        if (xp == (xppl = xpp.left)) {
            //爺爺節點的右節點不等于null且為紅色
            //滿足紅黑樹插入平衡情況一: 插入節點的父節點和其叔叔節點(爺爺節點的另一個子節點)均為紅色
            //則需要執行變色操作
            if ((xppr = xpp.right) != null && xppr.red) {
                xppr.red = false; //將爺爺節點的右節點置為黑色
                xp.red = false; //將父節點置為黑色
                xpp.red = true; //將爺爺節點置為紅色
                x = xpp; //將當前節點賦值為爺爺節點，再進行平衡操作
            }
            else {
                //若當前節點為父節點的右節點
                //滿足紅黑樹插入平衡情況二: 插入節點的父節點是紅色的，叔叔節點(爺爺節點的另一個子節點)是黑               //色的且插入節點是其父節點的右子節點。
                //由于當前父節點為爺爺節點的左節點，因此這里需要將當前節點的父節點作為新的節點，
                //以新的當前節點為支點做左旋操作
                if (x == xp.right) {
                    //將當前節點設置為父節點且執行左旋操作
                    root = rotateLeft(root, x = xp);
                    //重新設置爺爺節點和父節點
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }
                
                //若父節點不為空將其設置為黑色
                //滿足紅黑樹插入平衡情況三: 插入節點的父節點是紅色的，叔叔節點(爺爺節點的另一個子節點)                 //是黑色的，且插入節點是其父節點的左子節點。
                //由于當前父節點為爺爺節點的左節點，因此這里需要將當前節點的父節點涂黑，
                //爺爺節點涂紅，以爺爺節點為支點做右旋操作
                if (xp != null) {
                    xp.red = false; 
                    
                    //若爺爺節點不為空，將其設置為紅色并且執行右旋操作
                    if (xpp != null) {
                        xpp.red = true;
                        root = rotateRight(root, xpp);
                    }
                }
            }
        }
        //若父節點為爺爺節點的右節點
        else {
            //若要插入節點的爺爺節點的左節點非空且為紅色
            //滿足紅黑樹插入平衡情況一: 插入節點的父節點和其叔叔節點(爺爺節點的另一個子節點)均為紅色
            //則需要執行變色操作
            if (xppl != null && xppl.red) {
                xppl.red = false; //將要插入節點的爺爺節點的左節點設置為黑色
                xp.red = false; //將父節點設置為黑色
                xpp.red = true; //將爺爺節點設置為紅色
                x = xpp; //將當前節點賦值為爺爺節點，再進行平衡操作
            }
            //若要插入節點的爺爺節點的左節點為空或者為黑色
            else {
                //若當前節點為父節點的左節點
                //滿足紅黑樹插入平衡情況二: 插入節點的父節點是紅色的，叔叔節點(爺爺節點的另一個子節點)是黑               //色的且插入節點是其父節點的右子節點。
                //由于當前父節點為爺爺節點的右節點，因此這里需要將當前節點的父節點作為新的節點，
                //以新的當前節點為支點做右旋操作
                if (x == xp.left) {
                    root = rotateRight(root, x = xp); //將當前節點設置為父節點且執行右旋操作
                    
                    //重新設置爺爺節點和父節點
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }
                
                //若父節點不為空將其設置為黑色
                //滿足紅黑樹插入平衡情況三: 插入節點的父節點是紅色的，叔叔節點(爺爺節點的另一個子節點)                 //是黑色的，且插入節點是其父節點的左子節點。
                //由于當前父節點為爺爺節點的右節點，因此這里需要將當前節點的父節點涂黑，
                //爺爺節點涂紅，以爺爺節點為支點做左旋操作
                if (xp != null) {
                    xp.red = false; 
                    
                    //若爺爺節點非空
                    if (xpp != null) {
                        xpp.red = true; //爺爺節點設置為紅色
                        root = rotateLeft(root, xpp); //將爺爺節點執行左旋操作
                    }
                }
            }
        }
    }
}

//左旋操作
//root: 紅黑樹根節點
//p：當前節點
/*
* 左旋示意圖：對節點x進行左旋
*       p                        p
*      /                        /
*     x                        y
*   /   \                    /   \
* lx     y      ----->      x    ry
*      /   \              /   \
*    ly      ry          lx    ly
**/
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
                                      TreeNode<K,V> p) {
    //聲明r: 當前節點的右節點
    //pp：當前節點的父節點
    //rl: 當前節點右節點的左節點
    TreeNode<K,V> r, pp, rl; 
    
    //若當前節點不為null且當前節點的右節點不為空
    if (p != null && (r = p.right) != null) {
        //將當前節點右節點設置為當前節點右節點的左節點
        if ((rl = p.right = r.left) != null)
            rl.parent = p;
        
        //將當前節點右節點的父節點設置為當前節點的父節點
        //若父節點為null，則設置當前節點的右節點為根節點，同時設置為黑色
        if ((pp = r.parent = p.parent) == null)
            (root = r).red = false;
        
        //當前節點父節點非null且當前節點為父節點的左節點
        else if (pp.left == p)
            //父節點的左節點設置為當前節點的右節點
            pp.left = r;
        
        //當前節點為父節點的右節點
        else
            //將父節點的右節點設置為當前節點的右節點
            pp.right = r;
        
        //將當前節點設置為右節點的左節點
        r.left = p;
        
        //將當前節點的父節點設置為右節點
        p.parent = r;
    }
    return root;
}

//右旋操作
//root: 紅黑樹根節點
//p：當前節點
/*
 * 右轉示意圖：對節點y進行右旋
 *         p                    p
 *        /                    /
 *       y                    x
 *     /   \                /   \
 *    x     ry   ----->    lx    y
 *  /   \                      /   \
 * lx    rx                   rx   ry
 */
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
                                       TreeNode<K,V> p) {
    //聲明l: 當前節點的左節點
    //pp：當前節點的父節點
    //lr: 當前節點的左節點的右節點
    TreeNode<K,V> l, pp, lr;
    
    //當前節點非null且左節點非null
    if (p != null && (l = p.left) != null) {
        //若當前節點的左節點的右節點非null，則當前節點的左節點的右節點的父節點為當前節點
        if ((lr = p.left = l.right) != null)
            lr.parent = p;
        
        //將當前節點左節點的父節點設置為當前節點的父節點
        //若父節點為null，則設置當前節點的左節點為根節點，同時設置為黑色
        if ((pp = l.parent = p.parent) == null)
            (root = l).red = false;
        
        //當前節點父節點非null且當前節點為父節點的右節點
        else if (pp.right == p)
            //父節點的右節點設置為當前節點的左節點
            pp.right = l;
        
        //當前節點為父節點的左節點
        else
            //將父節點的左節點設置為當前節點的左節點
            pp.left = l;
        
        //設置左節點的右節點為當前節點
        l.right = p;
        
        //設置當前節點的父節點為左節點
        p.parent = l;
    }
    return root;
}

//用于確保紅黑樹中的根節點為數組中的下標節點(頭節點)
//tab: 節點數組
//root: 紅黑樹根節點
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
    int n;
    if (root != null && tab != null && (n = tab.length) > 0) {
        int index = (n - 1) & root.hash; //獲取紅黑樹節點在數組中的下標
        TreeNode<K,V> first = (TreeNode<K,V>)tab[index]; //獲取數組下標中的節點(頭節點)
        
        if (root != first) { //若紅黑樹的根節點不是頭節點的話
            Node<K,V> rn; //聲明紅黑樹根節點的后一個節點
            tab[index] = root; //設置數組下標的節點(頭節點)為紅黑樹根節點
            TreeNode<K,V> rp = root.prev; //聲明紅黑樹根節點的鏈表的前一個節點rp
            
            if ((rn = root.next) != null) //如果紅黑樹根節點的后一個節點不為空的話
                //設置紅黑樹根節點的下一個節點的前一個節點為根節點的前一個節點
                ((TreeNode<K,V>)rn).prev = rp; 
            
            
            if (rp != null) //若根節點的前一個節點不為空 
                rp.next = rn; //將根節點的前一個節點設置根節點的后一個節點
            
            
            //若頭節點不為null
            if (first != null) 
                first.prev = root; //將頭結點的前一個節點設置為紅黑樹根節點
            
            root.next = first; //紅黑樹根節點的后一個節點設置為頭結點
            root.prev = null;
        }
        //檢查紅黑樹是否正常
        assert checkInvariants(root);
    }
}

//遞歸檢查紅黑樹是否正常

//紅黑樹基本規則：
//1.每個節點不是紅色就是黑色的；
//2.根節點總是黑色的；
//3.如果節點是紅色的，則它的子節點必須是黑色的(反之不一定)，(也就是從每個葉子到根的所有路徑上不能有兩個連續的紅色節點)；
static <K,V> boolean checkInvariants(TreeNode<K,V> t) {
    //聲明父節點，左節點，右節點，前節點，后節點
    TreeNode<K,V> tp = t.parent, tl = t.left, tr = t.right,
    tb = t.prev, tn = (TreeNode<K,V>)t.next;
    
    //若前節點不為null且前節點的后節點不等于當前節點，證明和鏈表中位置不一致，異常
    if (tb != null && tb.next != t)
        return false;
    
    //若后節點不為null且后節點的前節點不等于當前節點，證明和鏈表中位置不一致，異常
    if (tn != null && tn.prev != t)
        return false;
    
    //若父節點不為null，且當前節點不是父節點的左節點又不是父節點的右節點，異常
    if (tp != null && t != tp.left && t != tp.right)
        return false;
    
    //若當前左節點不為null且左節點的父節點不等于當前節點或者左節點的hash值比當前節點的hash值大的話，異常
    if (tl != null && (tl.parent != t || tl.hash > t.hash))
        return false;
    
    //若當前右節點不為null且右節點的父節點不等于當前節點或右節點的hash值比當前節點的hash值小的話，異常
    if (tr != null && (tr.parent != t || tr.hash < t.hash))
        return false;
    
    //若當前節點為紅色，且左節點不為空且為紅色，且右節點不為空且為紅色，異常
    if (t.red && tl != null && tl.red && tr != null && tr.red)
        return false;
    
    //若左節點不為nul則遞歸判斷左節點
    if (tl != null && !checkInvariants(tl))
        return false;
    
     //若左節點不為nul則遞歸判斷右節點
    if (tr != null && !checkInvariants(tr))
        return false;
    
    //紅黑樹結構正常，返回true
    return true;
}

//紅黑樹的put操作
//map: 要put的hash map
//tab: 數組
//h: 要put的key-value的key的hash值
//k: 要put的key-value的key
//v: 要put的key-value的value
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                               int h, K k, V v) {
    Class<?> kc = null; //聲明key的class臨時變量
    boolean searched = false; //聲明是否搜索過的bool臨時變量
    TreeNode<K,V> root = (parent != null) ? root() : this; //獲取根節點
    
    //p為當前節點，從當前紅黑樹的根節點遍歷，找到要put的kay-value的key的對應節點或者
    //得到新節點在紅黑樹的位置
    for (TreeNode<K,V> p = root;;) { 
        int dir, ph; K pk; //聲明方向，當前節點的hash值，當前節點的key
        
        //若要put的key-value的key的hash值比當前節點hash值小
        if ((ph = p.hash) > h)
            dir = -1; //在當前節點左邊
        
        //若要put的key-value的key的hash值比當前節點hash值大
        else if (ph < h)
            dir = 1; //在當前節點右邊
        
        //若要put的key-value的key與當前紅黑樹節點的key相等，直接返回當前節點
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        
        //若還沒得到方向的話，下面代碼保證得到一個方向值
        else if ((kc == null &&
                  //若key的class實現了Comparable接口的話，直接比較兩個key，得到方向
                  (kc = comparableClassFor(k)) == null) || 
                 (dir = compareComparables(kc, k, pk)) == 0) {
            //判斷是否搜索過
            //該方法代表在put的時候會從紅黑樹中查找對應的key是否存在，若存在的話，
            //直接返回在紅黑樹中找到的節點。否則會將put的key-value封裝成一個紅黑樹節點
            //插入到紅黑樹中
            if (!searched) {
                TreeNode<K,V> q, ch; //聲明查找到的節點q和臨時節點遍歷ch
                searched = true; //將搜索標識置為true
                
                //若當前節點的左節點不為null并且從左節點開始查找節點，查找到的節點不為空的話
                //返回查找到的節點
                if (((ch = p.left) != null &&
                     (q = ch.find(h, k, kc)) != null) 
                    
                    ||
                    
                    //或
                   //若當前節點的右節點不為null并且從右節點開始查找節點，查找到的節點不為空的話
                    //返回查找到的節點
                    ((ch = p.right) != null &&
                     (q = ch.find(h, k, kc)) != null))
                    return q;
            }
            
            //該方法一定會返回一個要么為1，要么為-1的值(即一定會得到一個左/右的方向)
            dir = tieBreakOrder(k, pk);
        }

        //程序執行到這里證明要新創建一個紅黑樹節點，并將其插入的紅黑樹中
        
        TreeNode<K,V> xp = p;  //聲明父節點
        //判斷要插入的方向
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            Node<K,V> xpn = xp.next; //聲明父節點的后一個節點
            
            //根據key的hash值、key、value、父節點的后一個節點創建一個紅黑樹節點
            TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn); 
            
            //新節點在父節點的位置
            //即為父節點的左節點或右節點
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            
            //父節點的后一個節點為新節點
            xp.next = x;
            
            //新節點的父節點和新節點的前節點都為父節點
            x.parent = x.prev = xp;
            
            //如果父節點的后一個節點不為null的話，將父節點的后一個節點的前一個節點設置為新節點
            if (xpn != null)
                ((TreeNode<K,V>)xpn).prev = x;
            
            //重新平衡紅黑樹后檢查樹結構再移動根節點為數組下標節點(頭節點)
            moveRootToFront(tab, balanceInsertion(root, x));
            return null;
        }
    }
}

//返回包含此節點的紅黑樹的根節點
final TreeNode<K,V> root() {
    for (TreeNode<K,V> r = this, p;;) {
        if ((p = r.parent) == null)
            return r;
        r = p;
    }
}

//根據key的hash值，key，key的class，從紅黑樹的當前節點開始，找到對應的節點
//h: key的hash值
//k: key
//kc: key的class
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
    TreeNode<K,V> p = this; //賦值當前節點
    
    do {
        int ph, dir; K pk; //聲明當前key的hash值，方向，key
        TreeNode<K,V> pl = p.left, pr = p.right, q; //聲明當前節點的左節點，右節點，q為查找節點
        
        if ((ph = p.hash) > h)
            p = pl; //如果當前節點的hash值大于key的hash值，則將當前節點賦值為左節點繼續查找
        
        else if (ph < h)
            p = pr; //如果當前節點的hash值小于key的hash值，則將當前節點賦值為右節點繼續查找
        
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p; //如果hash值等于key的hash值，返回當前節點，證明找到了
        
        else if (pl == null) //如果左節點為null，則將當前節點當前賦值為右節點繼續查找
            p = pr;
        
        else if (pr == null) //如果右節點為null，則將當前節點當前賦值為左節點繼續查找
            p = pl;
        
        //若key的class實現了Comparable接口的話，通過Comparable接口比較兩個key的大小
        //將當前節點賦值為對應的方向的節點
        else if ((kc != null ||
                  (kc = comparableClassFor(k)) != null) &&
                 (dir = compareComparables(kc, k, pk)) != 0)
            p = (dir < 0) ? pl : pr;
        
        //若在上面接口得到kc后，這里通過find再尋找一次
        //若不為null，證明已找到對應key的節點，返回
        else if ((q = pr.find(h, k, kc)) != null)
            return q;
        
        //否當前節點直接賦值為左節點再繼續查找
        else
            p = pl;
        
    } while (p != null); //若當前節點不為null，繼續查找
    
    return null;
}
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 230,563評論 6贊 544
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 99,694評論 3贊 429
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事?！?“怎么了？”我有些...
    開封第一講書人閱讀 178,672評論 0贊 383
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 63,965評論 1贊 318
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 72,690評論 6贊 413
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 56,019評論 1贊 329
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 44,013評論 3贊 449
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 43,188評論 0贊 290
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 49,718評論 1贊 336
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 41,438評論 3贊 360
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 43,667評論 1贊 374
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 39,149評論 5贊 365
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,845評論 3贊 351
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 35,252評論 0贊 28
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 36,590評論 1贊 295
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 52,384評論 3贊 400
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 48,635評論 2贊 380