【源碼解析】HashMap擴容機制

目錄

使用

擴容機制

新增方法（put）

總結

---

hashMap是基於Hash表的Map實現，存儲的方式未key：value類型的鍵值對，同時允許key、value爲null，如果出現像如同的key或者value十，新值將會覆蓋之前的值。

使用

 //初始化HashMap
        Map<String,Object>  hashMap = new HashMap<String, Object>();

        //賦值
        hashMap.put("id",1);
        hashMap.put("name","張三");
        //取值
        Integer id = (Integer) hashMap.get("id");
        String name = (String) hashMap.get("name");
        System.out.println("id:"+id);
        System.out.println("name:"+name);

這就是一個簡單的馬匹使用，其中Map<String,Object>  你可以制定map的鍵值對類型，也可以不指定直接，如：

Map hashMap = new HashMap<();

這樣寫代表此map的鍵值對都是object類型的，你可以隨訪存放你的類型，如果你只想存儲String類型的key，int類型的value，聲明如下：

Map<String,Integer>  hashMap = new HashMap<String, Integer>();

在這裏需要注意一點，制定類型的時候只能十包裝類型，也就是   Long、Integer、Double等等，是不能使用long、int、double。

這裏還有一個問題，那就是如果我不知道我存的key是什麼我能拿到HashMap的數據嗎？當然可以

 //初始化HashMap
        Map<String,Object>  hashMap = new HashMap<String, Object>();
        //賦值
        hashMap.put("id",1);
        hashMap.put("name","張三");
        //取值
//        Integer id = (Integer) hashMap.get("id");
//        String name = (String) hashMap.get("name");
        //獲取所有的key值
        Set<String> keys=hashMap.keySet();//將map的key轉換成set集合
        Iterator<String> keyInterator1=keys.iterator();//將keys轉換成迭代器
        System.out.println("map的所有key值===============");
        while (keyInterator1.hasNext()){
            System.out.println(keyInterator1.next() );
        }
        System.out.println("map的所有value值===============");
        Collection<Object> values=hashMap.values();
        Iterator<Object> keyInterator2=values.iterator();
        while (keyInterator2.hasNext()){
            System.out.println(keyInterator2.next());
        }

請看結果：

是不是與上面的賦值對應上了

下面來介紹一下HashMap的性能以及安全問題

剛剛說了HashMap的存儲是基於hash算法實現的，那他具體是如何實現的呢？當程序執行HashMap的put方法時，將調用String的 hashCode() 方法得到其 hashCode 值，在這裏說明一下HashCode的因子是31，最後會根據計算出來的HashCode存放Map的元素.

 

擴容機制

我們先來看一下HashMap的初始化，HashMap提供了4中構造函數：
 

        //無參構造
        Map<String,Object> map1 = new HashMap<String, Object>();
        //有參構造   傳入初始容器大小
        Map<String,Object> map2 = new HashMap<String, Object>(100);
        //有參構造  傳入初始容器以及負載因子
        Map<String,Object> map3 = new HashMap<String, Object>(100,0.8f);
        //有參構造  講一個map賦值給一個新的map
        Map<String,Object> map4 = new HashMap<String, Object>(map1);

我們現在分別來看一下這幾個構造函數的源碼：
1.new HashMap()

/**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

此構造只做了一件事，那就是給負載因子賦初始值：0.75

2.new HashMap<String, Object>(100);

initialCapacity：初始化的容器大小
DEFAULT_LOAD_FACTOR：初始化的負載因子大小：0.75
threshold：容器的初始化大小
但是需要注意一點我們給的初始化容器大小：100並不是最終的大小，請看下面代碼：

 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;
    }

容器大小都是以2的冪形式，所以並不是我們實例化指定的，它是通過你給定的大小計算出最終的大小。

第三種和第二種構造一樣，唯一區別就是第三種可以手動指定負載因子，而第二種只能使用默認的負載因子，第四種事拷貝map到新的map中。

新增方法（put）

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; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            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;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

當第一次調用put()時，會進行一次resize()，resize主要作用：
1.擴容。
2.分配容器大小。
3.分配擴容的閾值。
4.如果發生擴容，數據拷貝。
源碼如下：
 

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
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        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"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    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 { // preserve order
                        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;
    }

我們使用第一個構造函數進行debug調式：
oldThr = threshold：容器的初始化大小，由於我們沒有指定，所以這裏等於0

請看，重點來了，請看下面這兩行代碼：

newCap：容器默認的大小：16
newThr：擴容的大小：容器大小 * 負載因子 = 16* 0.75 = 12

但是這裏需要注意一點，newCap不會作爲最終的容器大小，往下看你會發現程序將newThr（12）賦值給了threshold，也就是說容器的大小變成了12，而不是之前的默認大小16，這點需要特別注意，其實之前說的threshold（容器大小）不是真正的容器大小，而是需要進行擴容的閾值，那容器的大小是由哪個字段決定的呢？請看代碼：

容器的大小會被保留在table這個字段中，那一次擴容的大小是多少呢？我們來看下面這段代碼：

看到沒有，擴容的時候會執行oldThr << 1：oldThr 左移1位，也就是上一次的擴容閾值*2 = 12*2=24，所以下次容器中要塞滿24條數據才能再次出發擴容。

關於有參構造的擴容方式也是類似，只是在初始化resize的時候會使用給定的值（通過特定的算法得出的容器大小，上面已經講過了，並不是你傳入的大小，這點一定要特別注意）*負載因子而不是默認的值，感興趣的朋友可以自己跟着源碼走一遍，不難理解

總結

容器擴容是由容器大小以及負載因子共同決定的，同時容器大小和負載因子都是可以在初始化的時候指定，那是不是可以將負載因子設置爲1呢？讓數據達到容器的最大值在進行擴容，如果一定要這樣設計也是可以的，但是不推薦，設置的太高，可能會發生Hash碰撞問題，所以官方給出的0.75是一個比較合理的數值。

那我們實例化的時候HashMap的時候是否需要給定初始化容器大小呢？這個就要看具體需求了，如果map中存儲的數據不多，僅僅只是幾個查詢條件，那麼大可不必設置初始大小，默認的已經夠了，另外一種，我們需要用map接收幾萬的數據，這個時候就需要我們設置一下容器的初始化大小，爲什麼呢？，與如果不設置，那麼map在數據達到12的時候會進行一次擴容，數據達到24的時候進行一次擴容。。。。。。。幾萬的數據，會擴容很多次，但是孔融還有一點剛剛我沒有降到，那就是擴容時會伴隨着數據拷貝，擴容次數越多，拷貝的次數也就越多，這樣會浪費性能，所以到底如何選擇容器的大小，我們應該結合實際情況做出不同的方法。