JAVA集合：JDK 1.7 與 1.8HashMap 區別
阿新 • • 發佈：2018-12-09
生活
寫程式碼的時候總是想象維護你程式碼的傢伙是一個知道你住在哪裡的暴力精神病患者。
HashMap
在以前，學習JAVA集合時，只知道HashMap實現Map介面，底層是一個連結串列的陣列實現，執行緒不安全，具體咋樣，其實並沒有去看過。
前面看了ConcurrentHashMap,相信現在看HashMap的原始碼會簡單很多。
HashMap在 1.7和1.8下的實現有些不同，今天先來看1.7的實現。
成員
先來看下HashMap的成員組成
//預設初始化容量 16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 //最大容量 static final int MAXIMUM_CAPACITY = 1 << 30; //預設載入因子 0.75 static final float DEFAULT_LOAD_FACTOR = 0.75f; static final Entry<?,?>[] EMPTY_TABLE = {}; //連結串列陣列 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE; //元素個數 transient int size; //閾值 int threshold; //載入因子 final float loadFactor; //修改次數 transient int modCount; //針對string key 提供一個新的hash演算法減少衝突 static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
Entry
final int hash;
final K key;
V value;
Node<K,V> next;
建立
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; threshold = initialCapacity; init(); } public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } public HashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); } //上面的構造器並沒有執行桶的初始化。而是在第一次put時初始化 //只有這個需要初始化 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); }
來看下初始化桶的操作
//初始化桶 private void inflateTable(int toSize) { // Find a power of 2 >= toSize //把size設定為2的n次 int capacity = roundUpToPowerOf2(toSize); //設定閾值 threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); //建立 table = new Entry[capacity]; //這個方法在每次擴容的時候都會執行， //可以把它看成一個開關，如果開關開啟，並且key的型別是String時可以採取sun.misc.Hashing.stringHash32方法獲取其hash值。 /在JDK 8 中，hashSeed已經被移除掉了，移除掉的原因是呼叫sun.misc.Hashing.randomHashSeed計算hashSeed時會呼叫方法java.util.Random.nextInt()，該方法使用AtomicLong，在多執行緒情況下會有效能問題。 initHashSeedAsNeeded(capacity); }
至於 putAllForCreate 看下 挺簡單的
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putForCreate(e.getKey(), e.getValue());
}
private void putForCreate(K key, V value) {
int hash = null == key ? 0 : hash(key);
int i = indexFor(hash, table.length);
/**
* Look for preexisting entry for key. This will never happen for
* clone or deserialize. It will only happen for construction if the
* input Map is a sorted map whose ordering is inconsistent w/ equals.
*/
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
createEntry(hash, key, value, i);
}
有對應的key就直接替換value，沒有就建立一個新的entry
put
public V put(K key, V value) {
//如果這個連結串列陣列為空，就初始化一下
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//null key 塞在0號連結串列上
if (key == null)
return putForNullKey(value);
//取到對應的索引，遍歷他的連結串列，如果有這個key，那就替換value，否則就建立一個新的entry
int hash = hash(key);
int i = indexFor(hash, table.length);
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;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
//看一下addEntry
void addEntry(int hash, K key, V value, int bucketIndex) {
//如果容量上限那就要resize
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
//建立新的entry
createEntry(hash, key, value, bucketIndex);
}
關鍵要看下擴容時如何實現的
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
核心方法在transfer
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;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//根據hash值和新的容量重新計算位置
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
get
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
//根據hash值取到對應的index
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
//在遍歷這個連結串列
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
區別
JDK1.8下的HashMap較1.7做了很多優化：
1、由 陣列+連結串列 到 陣列+連結串列+紅黑樹。
【當連結串列的長度大於等於8時，會轉成紅黑樹？為什麼。因為長度8的連結串列查詢一個元素最多需要4次，而一個8個元素的紅黑樹最多隻需要查詢3次。
當紅黑樹資料小於等於6時，會轉回連結串列。因為小於等於6的連結串列查詢已經很快了，如果依舊使用紅黑樹，它的左旋右旋操作反而會使效能降低。
其次，選擇6和8，中間還有7，可以防止 頻繁的在連結串列與紅黑樹之間變換。
】
2、實現了高效的Hash演算法，用&取代%，在效果一樣的前提下保證了高效，
整個過程本質上就是三步：
拿到key的hashCode值
將hashCode的高位參與運算，重新計算hash值
將計算出來的hash值與(table.length - 1)進行&運算
這種實現方法保證了擴容後 原桶的資料要麼在原來的位置，要麼在2*原桶的位置
3、JDK1.7下的HashMap在多執行緒併發put ,resize時會出現迴圈連結串列的情況。導致get出現死迴圈，
在1.8下不會出現。原理是：
宣告兩對指標，維護兩個連連結串列【原桶 2*原桶】
依次在末端新增新的元素。（在多執行緒操作的情況下，無非是第二個執行緒重複第一個執行緒一模一樣的操作）
1.8原始碼深入
這裡就簡單看下 resize和hash
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) {
//關鍵的就是這個next置空，有效杜絕了迴圈連結串列
hiTail.next = null;
//將這個連結串列放到對應桶
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
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])
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
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);
}
}
return null;
}
假設桶的長度為16，取一個key的桶位置,如圖：
這篇部落格講解1.8的HashMap非常詳細
https://blog.csdn.net/v123411739/article/details/78996181