jdk源碼——hashmap

/**
 * HashMap是基於哈希表的 Map 接口的實現。此實現提供全部可選的映射操做，並容許使用 null 值和 null 鍵。當null爲鍵值時，其鍵的hash值爲0
 * 此類不保證映射的順序，特別是它不保證該順序恆久不變。 
 * HashMap與Hashtable的區別：HashMap是非synchronized的，並能夠接受null的鍵(key)和值(value)，而Hashtable的每一個方法都是synchronized的，且不可接受null的鍵(key)和值(value)。
 * Hashtable與ConCurrentHashMap的區別：Hashtable由於是對每一個方法加上synchronized進行同步的，所以其是對整個對象進行同步，而ConCurrentHashMap使用分段所技術，所以其性能要好一些。
 * 
 */
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    private static final long serialVersionUID = 362498820763181265L;

    /**
     * 默認容量爲16
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 容量的最大值爲2^30個
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 默認的填充因子爲0.75
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 當桶中元素個數超過這個值時須要使用紅黑樹結構替換單向鏈表結構
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 當擴容時，桶中元素個數小於這個值就會把樹形的桶元素還原爲鏈表結構
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 在轉變成樹以前，還會有一次判斷，只有鍵值對數量大於 64 纔會發生轉換。這是爲了不在哈希表創建初期，多個鍵值對剛好被放入了同一個鏈表中而致使沒必要要的轉化。
     */
    static final int MIN_TREEIFY_CAPACITY = 64;
    
    /**
     * 存儲元素的數組，老是2的冪次倍
     */
    transient Node<K,V>[] table;

    /**
     * 存放具體元素的集
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /**
     * 存放元素的個數，注意這個不等於數組的長度。
     */
    transient int size;

    /**
     * 每次擴容和更改map結構的計數器
     */
    transient int modCount;

    /**
     * 臨界值 當實際大小(容量*填充因子)超過臨界值時，會進行擴容
     */
    int threshold;

    /**
     * 填充因子
     */
    final float loadFactor;

    /**
     * 返回大於等於cap的最小的二次冪數值。
     */
    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;
    }

    /**
     * 
     */
    public HashMap(int initialCapacity, float loadFactor) {
    	// 初始容量不能小於0，不然報錯
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        // 初始容量不能大於最大值，不然爲最大值
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        // 填充因子不能小於或等於0，不能爲非數字
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        // 初始化填充因子
        this.loadFactor = loadFactor;
        // 初始化threshold大小
        this.threshold = tableSizeFor(initialCapacity);
    }

    /**
     * 將m的全部元素存入本HashMap實例中
     */
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
        	// 判斷table是否已經初始化
            if (table == null) {
            	// 未初始化，s爲m的實際元素個數
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
                // 計算獲得的t大於閾值，則初始化閾值
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            // 已初始化，而且m元素個數大於閾值，進行擴容處理
            else if (s > threshold)
                resize();
            // 將m中的全部元素添加至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);
            }
        }
    }

    /**
     * 在hash表中尋找hash值爲hash，鍵爲key的節點
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        // 若是table已經初始化，長度大於0，根據hash尋找table中的項也不爲空則開始尋找，不然返回null
        if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
        	// 若是桶中第一項(數組元素)知足尋找條件，則返回第一項
            if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            // 若是桶中不止一個結點
            if ((e = first.next) != null) {
            	// 若是爲紅黑樹結點
                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;
    }

    /**
     * 判斷是否存在鍵爲key的鍵值對
     */
    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }

    /**
     * 添加一個鍵爲key值爲value的鍵值對
     */
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    /**
     * 向map中添加一個元素，onlyIfAbsent爲false時，若是存在與鍵key相等的元素，將其值替換爲value，並將原來的值返回，不然不作替換
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // table未初始化或者長度爲0，進行擴容
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // (n - 1) & hash 肯定元素存放在哪一個桶中，桶爲空，新生成結點放入桶中(此時，這個結點是放在數組中)
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 桶中已經存在元素
        else {
            Node<K,V> e; K k;
            //與桶中第一個元素(數組中的結點)比較，若是hash值相等，key相等，
            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            	// 將第一個元素賦值給e，用e來記錄
                e = p;
            //若是hash值不相等，即key不相等；且節點爲紅黑樹結點
            else if (p instanceof TreeNode)
            	// 放入樹中
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //若是爲鏈表結構
            else {
            	// 在鏈表最末插入結點
                for (int binCount = 0; ; ++binCount) {
                	// 經過e = p.next和p = e遍歷該桶中的鏈表，直到鏈表的尾部
                    if ((e = p.next) == null) {
                    	// 在尾部插入新結點
                        p.next = newNode(hash, key, value, null);
                        // 結點數量達到閾值，轉化爲紅黑樹
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //在循環鏈表時再次對其中的元素進行判斷，看是否有元素的hash和鍵重複，若是重複則跳出循環
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 若是此時e不爲null，表示在桶中找到key值、hash值與插入元素相等的結點
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                // onlyIfAbsent爲false或者舊值爲null爲false或者舊值爲null時替換其值
                if (!onlyIfAbsent || oldValue == null)
                	//用新值替換舊值
                    e.value = value;
                // 訪問後回調
                afterNodeAccess(e);
                // 返回舊值
                return oldValue;
            }
        }
        //結構性修改，計數器+1
        ++modCount;
        // 實際大小大於閾值則擴容
        if (++size > threshold)
            resize();
        // 插入後回調
        afterNodeInsertion(evict);
        return null;
    }

    /**
     * 擴容，從新設置map中hash表的大小，而且將桶中的元素從新擺放
     * 進行擴容，會伴隨着一次從新hash分配，而且會遍歷hash表中全部的元素，是很是耗時的。在編寫程序中，要儘可能避免resize。
     * 即儘可能預估好元素的個數，在hashmap初始化時就指定容量
     * 須要注意的一點是，由於resize後的table的大小爲原來的兩倍，所以原來table中的元素resize後的位置只有兩種可能一種就是原來的桶中，一種是原來的桶的位置加上原來table的長度的位置。
     */
    final Node<K,V>[] resize() {
    	// 將當前table保存
        Node<K,V>[] oldTab = table;
        // 保存當前table大小
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 保存當前閾值
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 若是以前table大小大於0
        if (oldCap > 0) {
        	// 若是以前table的大小大於最大容量
            if (oldCap >= MAXIMUM_CAPACITY) {
            	// 將閾值設置爲最大整形
                threshold = Integer.MAX_VALUE;
                //返回舊的table
                return oldTab;
            }
            //若是原來的容量大於初始容量，且將其增爲兩倍後仍然小於最大容量
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            	// 閾值翻倍
                newThr = oldThr << 1; //
        }
        // 若是以前閾值大於0
        else if (oldThr > 0) //
            newCap = oldThr;
        //若是oldCap = 0而且oldThr = 0，使用缺省值
        //當使用如使用HashMap()構造函數，以後再插入一個元素會調用resize函數，會進入這一步
        else {
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 若是新閾值爲0
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        /**
         * 初始化一個存儲節點的數組，其大小由上面的代碼獲得是2的整數次冪
         */
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        // 若是以前的table已經初始化過
        if (oldTab != null) {
        	// 複製元素，從新進行hash
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //若是原來的桶中只有一個元素，則直接放到resize後相應的桶中
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //若是桶的數據結構爲紅黑樹，則對紅黑樹進行裁剪
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //若是桶的數據結構爲鏈表，則將同一桶中的元素根據(e.hash & oldCap)是否爲0進行分割，分紅兩個不一樣的鏈表，完成rehash
                    else {
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        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) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

    /**
     * 若是存在節點的鍵爲key的節點則將其刪除並返回此節點，不然不作更改
     * matchValue爲true時還須要判斷值相等才能進行刪除
     * movable是否將刪除節點後新的紅黑樹的根節點移到鏈表的開頭位置
     */
    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;
        //若是table不爲null，且table的長度大於0，而且hash值對應的桶中元素不爲null，則進入下一步，不然返回null
        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;
            //若是桶中的第一項的hash和key值與給定的值相等，即第一項爲要尋找的元素，則將其值賦值給node
            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);
                }
            }
            //若是node不爲null，說明找到了key值相等的節點，可是若是還須要對比值相等的話，則還要知足value值相等
            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;
                //HashMap的修改次數+1
                ++modCount;
                //HashMap的元素個數-1
                --size;
                //調用afterNodeRemoval方法，該方法HashMap沒有任何實現邏輯，目的是爲了讓子類根據須要自行覆寫
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }
}