首先來看看HashMap，從構造函數看起

HashMap有四個構造函數

第一個：

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

無參的構造函數，初始容量為默認的16不變，loadFactor為負載因子，也是默認的0.75

?

第二個：

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

調用第三種構造函數，建立一個大小為initialCapacity，負載因子為0.75的hashmap

第三個：

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);this.loadFactor = loadFactor;this.threshold = tableSizeFor(initialCapacity);}

參數為大小和負載因子，建立參數為initialCapacity，負載因子為loadFactor的hashmap

當大小大于MAXIMUM_CAPACITY(1<<30)時，就把大小設為最大

否則調用threshold設定大小(因為大小必須為2的次方數)

tableSizeFor的代碼為:

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

比如：預設定的大小cap = 6

n=6-1=5

n：? ? ? 0000 0101

n>>1：0000 0010

n|=.. ：0000 0111

?

n：? ? ? 0000 0111

n>>2：0000 0001

n|=：? ?0000 0111

......

n最終結果是0000 0111

這個運算的結果就是算出cap的最高非零位開始后面低位都是1的結果

因為5的最高非零位在倒數第三位，所以倒數第三位及以后都是1

之后對n+1，得出0000 1000

也就是8

所以這個方法就是得出大于等于cap的最小的2的冪次方

因為5<8,所以得出最終結果就是8

?

那為什么一開始cap要減一呢,就是為了邊界問題，針對cap=2的冪次的情況

比如cap=8時，如果不減一的話：

n = cap

n：? ? ? 0000 1000

n>>1：0000 0100

n|=：? ?0000 1100

?

n：? ? ? 0000 1100

n>>2：0000 0011

n|=：? ?0000 1111

......

n最終結果為0000 1111

之后對n+1，得出0001 0000，結果為16

但是我們一開始要的大小只是8啊，這給的多了一倍，浪費啊，浪費啊！

所以一開始減一，那么cap是8的時候，n就是7，那最終運算出的n就是8了

?

第四個：

public HashMap(Map<? extends K, ? extends V> m) {this.loadFactor = DEFAULT_LOAD_FACTOR;putMapEntries(m, false);}

構造一個大小和指定map一樣大的新map，負載因子為0.75

我們來看看第四個構造函數怎么實現的，通過調用putMapEntries方法

? final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {//通過s保存指定map的大小int s = m.size();//當指定的map m中有值時if (s > 0) {//如果table沒初始化，進行一些初始化if (table == null) { // pre-size//根據要存入map的值確定新map的容量float ft = ((float)s / loadFactor) + 1.0F;int t = ((ft < (float)MAXIMUM_CAPACITY) ?(int)ft : MAXIMUM_CAPACITY);//把要創建的容量大小值存入thresholdif (t > threshold)threshold = tableSizeFor(t);}//table初始化時，別的方法可能也會調用這個方法//所以如果table已經初始化，判斷初始化的大小和指定map的大小//如果比指定map的大小小，存不下，就需要resize()重新設定大小else if (s > threshold)resize();//遍歷m，將里面的值都放到新map之中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);}}}?

先來看看上面代碼調用的resize()方法

? 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) {//threshold是hashmap所能容納的最大數據量的Node個數//如果老表大小大于最大值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}//如果老表為空，同時老表大小大于0，那么新表長度就為老表容量else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;//如果老表大小為0，新表長度設為默認的16else { // zero initial threshold signifies using defaultsnewCap = 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;//把老表中的數據rehash到新表當中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 orderNode<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;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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;}?

HashMap通過鏈表法避免沖突

當鏈表長度大于8時，把鏈表轉換為紅黑樹

當鏈表長度小于6時，又轉回鏈表

而存儲hashmap值的數據結構為數組

所以hashmap的數據結構組成為數組，鏈表，紅黑樹。

我們再來看看之前的putVal方法

putVal(hash(key), key, value, false, evict);

看putVal之前先看看hash方法

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

將key的hashcode值與他的hashcode右移16位的結果進行異或運行，得出哈希值

這樣做的原因：高低位混合進行異或運算，增大隨機性

putVal()方法如下所示：

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位空則resizeif ((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;//key與原來存在這個位置的key相同，只更新valueif (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 1sttreeifyBin(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 keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold)resize();afterNodeInsertion(evict);return null;}

JDK1.7及以前沒有紅黑樹這個數據結構，只是通過鏈表來處理沖突

所以采用頭插法效率高

但是這樣可能會產生兩個問題

一是鏈表逆序

二是可能死循環

紅黑樹采用尾插法解決了這個問題

?

安全性問題：

HashMap為什么是不安全的？

當多線程時，線程a，b對同一位置進行插入元素，當a獲取到這個位置的地址，準備插入時，時間片用完了，現在輪到b插入，b它處理快，直接插入成功了，現在a開始插入，就覆蓋了b的數據。

?

當需要擴容時，兩個線程同時對hashmap進行擴容，會導致產生循環鏈表

?

所以為了安全性問題，我們有了concurrenthashmap

總結

以上是生活随笔為你收集整理的HashMap源码分析(搞懂HashMap看这个就够了)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。