Map—HashMap源碼剖析

Map接口是java中保存二元偶對象（鍵值對）的最頂層接口
Map接口下的常用子類
HashMap（使用頻率最高）、TreeMap、Hashtable、ConcurrentHashMap

Map集合的遍歷： 將Map集合轉化爲Set集合進行遍歷

• 使用迭代器進行輸出：Iterator

 Set<Map.Entry<Integer,String>> entrySet =
                map.entrySet();//將Map變爲Set  通過Set取得迭代器
        Iterator<Map.Entry<Integer,String>> iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry<Integer,String> entry =
                    iterator.next();
            System.out.println(entry.getKey()+" "+entry.getValue());
        }

映射：一個鍵對應一個值
將每一對key和value看做一個對象，每一個對象就是一個Entry，一個Map是由多個Entry對象來組成的。調用entrySet()方法後返回Set<Map.Entry<Integer,String>>類型集合
Map.Entry的作用：Map.Entry裏有相應的getKey和getValue方法，讓我們能夠同時取出Key和Value者一對值。
下面讓我們以Map中的HashMap爲例，探究一下源碼的實現：
首先有這麼幾個成員變量：

• 初始化容量：DEFAULT_INITIAL_CAPACITY = 16；桶的數量
• 負載因子：DEFAULT_LOAD_FACTOR = 0.75f（擴容時）
• 樹化閾值：TREEIFY_THRESHOLD = 8
• 樹化的最少元素個數：MIN_TREEIFY_CAPACITY = 64
• 解樹化，返回鏈表閾值：UNTREEIFY_THRESHOLD = 6**

構造方法：

• 無參構造：這裏並沒有初始化HashMap,而只是初始化了負載因子

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

• 有參構造：一個參數的構造方法只是調用了有參的構造方法

public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

• 有參構造：兩個參數的構造方法也沒有進行初始化，只是將變量進行賦值
  

普通方法：

• static final int tableSizeFor(int cap)

  tableSizeFor（）這個方法的作用是將輸入的參數變爲距離這個數最近的2 的整數次方

• put（）方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
//當前hash表未初始化
    if ((tab = table) == null || (n = tab.length) == 0)
//resize（）完成哈希表初始化
        n = (tab = resize()).length;
//根據key值hash後得到桶下標，並且此時桶中元素個數爲空
    if ((p = tab[i = (n - 1) & hash]) == null)
//將要保存的結點放置在此桶的第i個元素
        tab[i] = newNode(hash, key, value, null);
    else {//此時hash表已經初始化了並且桶中已經有數據了
        Node<K,V> e; K k;
//若桶中原來元素的hash=你要設置的元素的hash且桶中原來元素的key=你要設置的元素的key
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
//將value做替換
            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) {
                if ((e = p.next) == null) {
//將新結點鏈到鏈表尾部
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
//判斷添加元素之後整個哈希表大小是否超過threshod
    if (++size > threshold)
//若超過，調用resize（）方法擴容
        resize();
    afterNodeInsertion(evict);
    return null;
}

向HashMap中添加元素時，存在樹化邏輯，刪除時存在解樹化

• 樹化邏輯：當一個桶中鏈表元素個數>=8並且哈希表的長度超過64，此時會將此桶中鏈表結構轉爲紅黑樹，若只是鏈表個數>8,但哈希表的元素不超過64，此時只是簡單的resize（擴容），並不會樹化。（提高鏈表過長導致的查找太慢問題，從原來的O（n）優化爲O（log n），減少hash碰撞）
• 解樹化：當紅黑樹節點個數在擴容或刪除時個數<=6,在下一次擴容時會將紅黑樹轉化爲鏈表

將put方法看完後就會提出幾個問題：
1.HashMap中容量均爲2^n
保證哈希表中的所有索引都能被訪問到。
舉個例子，如果容量是15，那利用（n-1）&hash進行運算時，n-1的二進制碼後四位爲1110，這樣無論hash值是多少都會出現有的索引不被訪問到。所以就要保證是2 ^n。此時n-1 的二進制位1111,就不會出現這種問題。當n爲2的n次方時，此時的位運算就相當於hash%n

2.負載因子：DEFAULT_LOAD_FACTOR = 0.75f作用？
計算有效桶個數：threshold=桶個數*負載因子
當負載因子>0.75時：增加了哈希表的利用率，哈希衝突概率明顯增加
當負載因子<0.75時：降低了哈希表的利用率，導致頻繁擴容，哈希衝突概率明顯降低

• get方法：

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
        //當前節點key值剛好是桶的第一個節點
            return first;
       //遍歷桶的其他節點找到指定key值返回其value
        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);
        }
    }
    //當表還未初始化或key值爲null
    return null;
}

看這段源碼：爲何取出key值的高16位右移參與hash運算？（h >>> 16）

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

因爲hash基本上是在高16位進行hash運算，保留高16位，讓高低16位都參與異或運算，降低hash衝突的概率

• resize方法：
  如果表爲null，則oldCap=0；若oldCap>0,並且已經大於等於最大容量，就讓有效桶個數等於整型最大值，返回原來的表，當oldCap擴大2倍後仍小於最大容量，並且oldCap大於默認容量，就讓他擴容兩倍，否則進行初始化操作
  在HashMap擴容之後要進行數據的搬移，在搬移的過程中原來的元素在新的HashMap中的位置是原位置或原位置的2倍。
  原因是：假設原來容量爲16 ，根據下列公式進行計算
  
  *