【攻防世界】：新手區 | guess number
一 建構函式
1.1HashMap(int initialCapacity)
public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
這個構造方法呼叫了1.2中的構造方法。
1.2HashMap(int initialCapacity, float loadFactor)
//構造一個初始容量為initialCapacity，負載因子為loadFactor的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); }
設定threshold，這個threshold = capacity * load factor。當HashMap的size到了 threshold時，就要進行resize,也就是擴容。tableSizeFor()的主要功能是返回一個比給定整數大且最接近的2的冪次方整數,如給定10,返回2的4次方16.
我們進入tableSizeFor(int 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; }
詳細請看：https://www.jianshu.com/p/ee0de4c99f87
1.3HashMap(Map<? extends K, ? extends V> m)
public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
直接看putMapEntries(m, false)原始碼：
//將m的所有元素存入HashMap中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); if (s > 0) { if (table == null) { // pre-size float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); if (t > threshold) threshold = tableSizeFor(t); } else if (s > threshold) resize(); 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); } } }
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; 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; }
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) { 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; }
注: hash 衝突發生的幾種情況:
1.兩節點key值相同(hash值一 定相同)，導致衝突;
2.兩節點key值不同，於hash函式的侷限性導致hash值相同，衝突;
3.兩節點key值不同，hash 值不同，但hash值對陣列長度取模後相同，衝突;
二，為啥是執行緒不安全的？
1. put的時候導致多執行緒資料不一致
比如有兩個執行緒A和B，首先A希望插入一個key-value對到HashMap中,首先計算記錄所要落到
的hash桶的索引座標，然後獲取到該桶裡面的連結串列頭結點，此時執行緒A的時間片用完了，而此
時執行緒B被排程得以執行，和執行緒A-樣執行，不過執行緒B成功將記錄插到了桶裡面，假設線
程A插入的記錄計算出來的hash桶索弓|和執行緒B要插入的記錄計算出來的hash桶索引是-樣
的，那麼當執行緒B成功插入之後,執行緒A再次被排程執行時，它依然持有過期的連結串列頭但是它對
此一無所知，以至於它認為它應該這樣做，如此一來就覆蓋了執行緒B插入的記錄，這樣執行緒B插
入的記錄就憑空消失了，造成了資料不一致的行為。
2. resize而引|起死迴圈
這種情況發生在HashMap自動擴容時，當2個執行緒同時檢測到元素個數超過陣列大小x負載因
子。此時2個執行緒會在put(方法中呼叫了resize(),兩個執行緒同時修改-個連結串列結構會產生-個
迴圈連結串列(JDK1.7中, 會出現resize前後元素順序倒置的情況)。接下來再想通過get()獲取某
一個元愫，就會出現死迴圈。
三 HashMap和HashTable的區別
HashMap和Hashtable都實現了Map介面，但決定用哪一個之 前先要弄清楚它們之間的分別。主要
的區別有:執行緒安全性,同步(synchronization), 以及速度。
1. HashMap幾乎可以等價於Hashtable,除了HashMap是非synchronized的,可以接受
null(HashMap可以接受為null的鍵值(key)和值(value)，而Hashtable則不行)。
2. HashMap是非synchronized,而Hashtable是synchronized, 這意味著Hashtable是執行緒安全
的，多個執行緒可以共享一個Hashtable; 而如果沒有正確的同步的話，多個執行緒是不能共享
HashMap的。Java 5提供了ConcurrentHashMap,它是HashTable的替代， 比HashTable的擴 展
性更好。
3.另一個區別是HashMap的迭代器(lterator)是fail-fast迭代器，而Hashtable的enumerator迭代器
不是fail-fast的。所以當有其它執行緒改變了HashMap的結構(增加或者移除元素)，將 會丟擲
ConcurrentModificationException,但迭代器本身的remove(方法移除元素則不會丟擲
ConcurrentModificationException異常。這並不是一個發生的行為，要看JVM。這條同
樣也是Enumeration和Iterator的區別。
4.由於Hashtable是執行緒安全的也是synchronized,所以在單執行緒環境下它比HashMap要慢。如
果你不需要同步，只需要單一執行緒, 那麼使用HashMap性 能要好過Hashtable。
5. HashMap不能保證隨著時間的推移Map中的元素次序是不變的。
注意一下重要術語：
1. sychronized意味著在一次僅有一個執行緒能夠 更改Hashtable。就是說任何執行緒要更新Hashtable
時要首先獲得同步鎖，庀執行緒要等到同步鎖被釋放之後才能再次獲得同步鎖更新
Hashtable。
2. Fail-safe和iterator迭代器相關。如果某個集合物件建立了Iterator或者Listlterator,然後其它的
執行緒試圖"結構上”更改集合物件，將會丟擲ConcurrentModificationException異常。但其它線
程可以通過set()方法更改集合物件是允許的，因為這並沒有從“結構上”更改集合。但是假如已
經從結構上進行了更改,再呼叫set(方法, 將會丟擲llgalArgumentException異常。
3.結構上的更改指的是刪除或者插入一個素，這樣會影響到map的結構。
HashMap可通過如下語句進行同步：
Map m=Collections.synchronizedMap(hasMap);