JDK7HashMap

JDK7HashMap

成員變量

HashMap中定義了很是多的成員變量以及常量，各成員變量含義具體以下：

//默認初始化長度-16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默認加載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//空entry數組
static final Entry<?,?>[] EMPTY_TABLE = {};
//table存放數據
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//數組包含元素個數
transient int size;
//數組擴容閾值=capacity*load_factor
int threshold;
//加載因子
final float loadFactor;

DEFAULT_INITIAL_CAPACITY爲何設置爲16，建立HashMap的時候須要設置值嘛？

這些問題將等下揭曉。

DEFAULT_LOAD_FACTOR爲何設置爲0.75？

JDK官方基於空間與時間成本作出的均衡，加載因子越大，擴容越晚，節省空間，哈希碰撞越多，put、get效率越低，至於爲何是0.75，這是一個數學or統計問題？再次不作深究

HashMap的存儲結構

//成員變量Entry數組
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
static final Entry<?,?>[] EMPTY_TABLE = {};

//內部類Entry，實現了Map.Entry接口
static class Entry<K,V> implements Map.Entry<K,V>{
    	final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
}

由此能夠看出，JDK7的HashMap的存儲結構是經過數組加鏈表的方式實現的，瞭解了put方法以後也能明白，HashMap採用的是衝突鏈表的方式解決哈希碰撞

JDK7的HashMap構造方法

public HashMap() {   
    //調用默認初始長度16，默認加載因子0.75
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity) {
    //默認加載因子0.75
        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;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
		//對loadFactor賦值以及threshold賦值
        this.loadFactor = loadFactor;
        threshold = initialCapacity;
    	//空方法，交由子類實現，在HashMap中無用
        init();
}

//插入整個map
public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
}

咱們在構造函數中傳入的capacity實際上賦值給了threshold參數，而不是table數組真正的大小，table數組真正的大小在put第一個元素時

核心方法put()詳解

put()

public V put(K key, V value) {
    	//判斷table是否爲EMPRT_TABLE
        if (table == EMPTY_TABLE) {
            //用大於threshold的2次冪初始化table
            inflateTable(threshold);
        }
    	//若是key爲null
        if (key == null)
            return putForNullKey(value);
    	//對key進行hash
        int hash = hash(key);
    	//根據hash值肯定數組下表，經過&操做得到
        int i = indexFor(hash, table.length);
    	//遍歷鏈表，尋找key相同的元素，而且修改value
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                //recordAccess空方法
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

inflateTable()

若是是第一次put，在構造函數處咱們傳入的capacity賦值給了threshold，而threshold被傳遞到了toSize，咱們的capacity才真正的起做用

private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize尋找一個大於toSize的2次冪
        int capacity = roundUpToPowerOf2(toSize);
		//咱們傳入的capacity賦值給了threshold，然而此刻threshold又被修改了，hashMap老渣男了
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
    	//哈希種子，跳過
        initHashSeedAsNeeded(capacity);
}

經過費勁心機的一通位運算，三目運算符，拿到了一個比在構造函數中傳入的capacity大的二次冪，這是爲啥呢？

爲何就非得是個二次冪？

這個問題等下hash回答

費勁心機的roundroundUpToPowerOf2()

private static int roundUpToPowerOf2(int number) {
    // assert number >= 0 : "number must be non-negative";
    int rounded = number >= MAXIMUM_CAPACITY
        ? MAXIMUM_CAPACITY
        : (rounded = Integer.highestOneBit(number)) != 0
            ? (Integer.bitCount(number) > 1) ? rounded << 1 : rounded
            : 1;

    return rounded;
}

解釋一下上面的代碼，能夠說很是之精妙的了，因爲裏面參雜了大量的三目運算符使得看起來很是難受，下面用僞代碼解釋一下，其中以數字7舉例，其二進制的後四位爲：0111

if number>=MAXIMUM_CAPACITY
	rounded=number=MAXIMUM_CAPACITY
else
	//這裏返回的是number二進制的最高位那個1，通俗點來講就是小於number的最大2次冪
	//會有詳細分析JDK是如何操做的
	//rounded=0100=4
	rounded=Integer.hightestOneBit(number)
	if rounded！=0
		//這裏統計了number二進制表示中1的個數,0111--3個1
		if Integer.bitCount(number)>1
			//若是超過1，則rounded左移一位就是大於num的最小二次冪，也就是1000--8>7
			rounded=rounded<<1
		else
			//若是==1，代表rounded==number
			rounded=rounded
	else
		//rounded爲0，賦值爲1
		rounded=1

其中highestOneBit()、bitCount()中包含了大量的位運算，很是的精妙，詳解另外一篇講解(待補)

hash()

回到put方法中，在第一次放入時，咱們已經建立好了table了，capacity也被咱們設置好了，threshold也被從新設置了，然咱們暫且忽略掉putForNullKey這個分支，進入hash方法，在這裏也會了解爲何capacity非得是個二次冪

final int hash(Object k) {
    int h = hashSeed;
    if (0 != h && k instanceof String) {
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

哈希方法最重要的性能考慮之一就是散，也就是儘可能減小哈希碰撞

例如字符串jack的hashcode的表現形式爲
1100011010011111011111

直接取這個hashcode值看成hash值行不行？固然能夠，可是有問題

在瞭解了下面的indexFor方法以後，發現hashMap採用位運算的方式計算元素對應的下標，這樣會有什麼問題呢？

1100011010011111011111
xxxxxxxxxxxxxxxxxxx111

問題很明顯了，若是後面111相同，在當前狀況下，前面的29位不一樣都會被映射到同一個位置，這無疑致使了大量的哈希碰撞，那麼爲了彌補在indexFor中的過錯，hash值的計算就須要儘量綜合全部bit的信息，因此hash方法中加入了擾動計算，算是爲indexFor的高效擦屁股吧！

indexFor()

hashMap就是經過以下的方法來計算某個key所計算出來的hash已經對應到數組的哪一個位置的，它相較於直接對length取餘有何優點呢？

• 與操做速度比除法取餘的方式更快
• 不用擔憂負數的問題

static int indexFor(int h, int length) {
    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
    return h & (length-1);
}

而着就要求length也就是capacity必須是一個二次冪

舉例說明 8--1000 8-1=7=0111，前28位的0省略

任何hash值與0111進行於操做，它的值只能落在0000-0111之間，也就正好是數組的範圍

這樣作值得嘛？

值得，entry被放入map中以後，它的hash值也被保存到了自身的成員變量之中通常來講不會變化，直接訪問便可，而在hashMap的最頻繁調用的方法get()中，indexFor效率的提高確定是很是棒的，所以犧牲hash的高效換取indexFor的高效無疑提升了整個HashMap的效率，況且hash中的操做也都是位運算

HashTable中的hash方法與index的計算

private int hash(Object k) {
    // hashSeed will be zero if alternative hashing is disabled.
    return hashSeed ^ k.hashCode();
}

int index = (hash & 0x7FFFFFFF) % tab.length;

能夠看出hashTable則選擇了較爲樸素的實現，爲何hashTable不跟進效率高的實現呢？總的來講就是Hashtable和HashMap的容量選取策略不一樣

• hashtabl選取素數容量，默認爲11，翻倍也是2*n+1的翻倍，素數的選擇使得簡單的取餘分佈就很均勻，這應該是數學上的知識了，不予證實
• hashMap選取二次冪做爲初始容量，默認16，翻倍也是2倍的翻倍，經過位運算實現高效的index計算，可是須要擾動計算hash值

addEntry()

put方法中找不到相同的key，此時須要添加新的entry

void addEntry(int hash, K key, V value, int bucketIndex) {
    	//若是size超過了threhold，
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //擴容擴容大小爲原數組的兩倍
            resize(2 * table.length);
            //擴容以後須要從新計算hash從新尋找index
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
		//頭插法插入鏈表
        createEntry(hash, key, value, bucketIndex);
}

頭插法createEntry()

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

頭插法致使的問題見

老生常談之擴容

resize()

以兩倍的容量擴張

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
		//resize(2 * table.length);
        Entry[] newTable = new Entry[newCapacity];
    	//轉移數據
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

transfor()

void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            //拷貝數組
            while(null != e) {
                Entry<K,V> next = e.next;
                //若是須要從新hash的話則從新hash
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                //頭插法
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
}

爲何擴容以後要從新對元素進行hash而後再散列呢？

舉例：

擴容前

length=16

h= 0001 1001

& 0000 1111

= 0000 1001=9

擴容後

h= 0001 1001

& 0001 1111

= 0001 1001=25

可見擴容以後的位置有兩種狀況：1.原位置不動 2.向後移動原數組長度個位置。所以，擴容以後在對數據進行復制的時候須要從新計算hash和index，這樣的擴容可以實現對鏈表長度的削減，以提升總體HashMap的查詢效率