HashMap 數據結構
Java 1.7 HashMap 的數據結構是 數組 + 鏈表
Java 1.8 HashMap 的數據結構是 數組 + 鏈表 + 紅黑樹
HashMap 重點參數
這裏是針對1.8總結的。
HashMap的默認初始化容量， 必須是二次冪
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量，由帶參數的任何一個構造函數執行。 必須是二次冪<= 1<<30。
static final int MAXIMUM_CAPACITY = 1 << 30;
//負載係數，容量*負載係數=負載因子、加載因子，當實際使用容量達到負載因子時進行擴容。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 紅黑樹的閾值 鏈表長度 >= 8 將會轉成一個紅黑樹
static final int TREEIFY_THRESHOLD = 8;
// 拆分樹時的閾值 紅黑樹的節點<=6的時候將會轉爲鏈表結構
static final int UNTREEIFY_THRESHOLD = 6;
// 紅黑樹最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
HashMap 的鏈表是單項還是雙向的
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next; // --- 這裏只有向下指針 所以單向的
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
HashMap 的構造方法
構造方法一共是4種
無參構造：HashMap() ，設置了一個默認負載因子
有參構造：HashMap(int initialCapacity, float loadFactor) ，initialCapacity是初始容量，loadFactor負載因子
有參構造：HashMap(int initialCapacity） ，initialCapacity是初始容量
有參構造： HashMap(Map<? extends K, ? extends V> m) ，m是Map參數
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
//自定義初始大小和負載係數
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);
}
//自定義初始大小
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//默認設定
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//帶參數構造
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);//添加參數
}
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);
}
}
}
HashMap 的GET（）方法
這個hash(key)方法是一個關鍵方法。它返回一個int值，這個值決定了Node<key , value>節點的位置。
我們都知道HashMap的數據結構，數組+鏈表然後根據情況決定是否轉爲紅黑樹（這個後面講），數組的每一個下標可以看成一個桶！那麼這個桶是什麼呢，就是 Node<>[]，就是Node的數組表示。我們來看一下node是個啥？
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
看代碼我們知道，Node是一個內部類，它有4個參數 hash key value next。這裏也有一個hash,這個hash 的值就來源於key.hashCode().
下面是get的源碼
重點是getNode()方法，找下標的這個算法。也就是第一個if的最後一個條件。
用文字來解析下這個代碼
一共是5個if
第一個 if：map不是空的，map指定的下標也不能是空的
第二個 if： first節點的hash於key（get(key)是這個key）的hash碼相等，並且 key於first.key特相等 ，那麼放回first
第三個 if：是判斷first是否有下一個節點
第四個 if：是判斷 first是不是樹類型，如果是就執行return ((TreeNode<K,V>)first).getTreeNode(hash, key);
如果不是那就循環鏈表，逐一比較key hash的值。相同返回節點數據。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
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]) != 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;
}
((TreeNode<K,V>)first).getTreeNode(hash, key);如果是紅黑樹，那是怎樣從樹種找到這個key 的呢？？
方法的源碼貼上一起來看看。
沒有什麼特別的吧。一串if else 就是取左節點還是右節點。
//root()這個方法就是個parent 賦值了一下，重點是find(h,k,null)方法！
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h) // 大於 h ,取左
p = pl;
else if (ph < h) // 小於 h ,取右
p = pr;
else if ((pk = p.key) == k || (k != null && k.equals(pk))) // 相同返回
return p;
else if (pl == null) // 爲空 取反
p = pr;
else if (pr == null) // 爲空取反
p = pl;
else if ((kc != null || //比較類型和可比性取元素
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null) // 迭代先找右邊
return q;
else
p = pl;
} while (p != null);
return null;
}
HashMap 的put(k，v)方法.
第一步當前的map是否創建/爲空。
第二步存儲的位置是否爲空， 爲空直接存 (位置的計算方法下面說哦）
第三步存儲的位置不爲空
3.1 位置hash 和 參數hash相同 切key相同，傳入的值和以保存的值相等（hash+key）不操作
3.2 存到爲紅黑樹
3.3 存到鏈表，循環找到下一個空閒的位置，並逐步將參數值與已存在的值進行比較（hash+key）
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;
//第一步當前的map是否創建/爲空。
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); --- node內部類的構造方法返回一個node
else {
//############################## 重點哦 #############################################
// 第三步存儲的位置不爲空
Node<K,V> e; K k;
//1位置hash 和 參數hash相同 切key相同，傳入的值和以保存的值相等（hash+key）不操作
//key值 或者 hash值是相同的直接替換，value會覆蓋之前的value值。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//2存到爲紅黑樹
//
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//3存到鏈表
//
for (int binCount = 0; ; ++binCount) {
// 鏈表下一個位置爲空
if ((e = p.next) == null) {
//保存數據
p.next = newNode(hash, key, value, null);
//##### 重點 #################
// 當長度>=8的時候 將鏈表轉爲一個紅黑樹
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;
// e = p.next , p=e, e = p.next 迭代
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;
}
############################紅黑樹存儲######################################
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h) // 左
dir = -1;
else if (ph < h) // 右
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk))) //已存在直接放回
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) { // 插找已經存在節點上是否存在key 存在直接返回
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) { // dir <=0 存在左節點 反之存在右節點
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
put（K，V）方法 存儲位置算法
node在數組中的下標位置。
結果 < 數組大小 ， 範圍是0 - （數組大小 - 1）
數 % 數組大小 = [0 - （數組大小 - 1）]
數使用的就是 key.hashCode(); 但是源碼中使用的方法和這個方法不一樣
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
（n -1） & hash
n 是數組大小 ， hash是key的hash值。使用的是 & 運算符。回憶一下 & 運算符是怎麼一個算法來着？？？
同爲1 結果爲1 ， 否則結果爲 0；
（16 - 1 ） & 3373707
111 轉10進制是 7. 最大值是01111 也是15.
根據計算啊 數%數組大小 結果範圍是 [ 數組大小 - 1 ]
根據計算啊 （n -1） & hash 結果範圍也是 [ 數組大小 - 1 ]
所以計算方式不同，但結果沒差別。之所一直這樣寫，是因爲最終執行代碼的是機器！二進制計算更快。
上面的做法雖然完成了任務，但是由於關鍵點在hash值得最後4位（這個是根據擴容而不斷增加的），怎樣保證結果能更爲均散嗎？
要想做到最後位的不相同，可以拆分爲 高16位 ，和低16位 ，然後高低做一個異或運算
高16位 1100011001110001
低16位 1001110000000111 ^ 回憶一下^運算： 同0爲0 不同爲1
——————————————————————
1101111001110111
看一下源碼：
嗯…反正就是打亂了一下
static final int hash(Object key) {
int h;
//這裏是hash ^ hash>>>16 (高16位) 這樣一個結果
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
上面保證了，hash是分散的， op2如果爲01110呢， 因爲是 & 運算，都爲1結果才爲1， op2的最後一位是0，那結果肯定爲0，這樣就有加大重複的可能性，這是怎麼辦呢？？？
那就保證 op2 的結果一定爲：0111111，0後面都爲1.
**op2 = (n -1) , n = 000000001; 00000001 - 1 = 01111111; **
那麼 n 必須爲2次冪。
源碼解決方法：
//如果你在構造參數中傳入的數，不是2的N次冪，咋辦？
//下面的源碼方法幫我們解決這個問題。
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;
}
HashMap 擴容
先想想 “擴容”這個動作需要幾步來完成？？？
- 第一步 既然要擴容，那必定是需要一個新的大的容器
- 第二步 新的容器有了，那就舊容器的數據拿過來。
- 第二步 之 1情況 下標中只有一個元素
- 第二步 之 2情況 下標中是一個鏈表數據
- 第二步 之 3情況 下標中是一個紅黑樹數據
第一步：擴容新數組源碼：
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length; //16
int oldThr = threshold; // 12
int newCap, newThr = 0;
if (oldCap > 0) { //擴容會進入這個if中執行
// oldCap >= 1<< 30
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// (oldCap << 1 = 32)< (1 << 30)
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
// 32 >= 16
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 12 << 1 = 24
newThr = oldThr << 1; // double threshold
}
// oldCap ===》 32 10000<<1 = 100000
// newThr ===》 24 1100<<1 = 11000
第二步：移動數據到新的數組中
擴容完成後： resize操作，老數組移動到新數組中
源碼展示：
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)//如果e沒有下一個元素 只有一個元素
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;
//##############
/* $運算 都爲1 結果爲1 否則爲0
結果爲0 與 不爲0
關鍵在於hash倒數第5位是否爲0
已知 oldCap是16 二進制是10000
所以 hsah倒數第5位爲0 結果爲0 ，倒數第5位爲1結果爲1
11000110011100011001110000000111 e.hash
10000 & oldCap &
--------------------------------------------------
與e.hash & (newCap - 1)這樣的效果一樣嗎？
是一樣的
結論：
hsah倒數第5位是0，結果爲0 成立，這時result和原來【擴容前】的結果一樣 原來的位置保持不變
hash倒數第5位是1，結果不爲0，這時和原來的結果倒數第5位多了一個1，也就是多了一個16，原來的位置+16（oldCap）
依次列推：16 32 64...
*/
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;
}
}
}
}
}
key.hashcode & (n-1) 這是put時是這樣的算法
e.hash & (newCap - 1) 擴容後舊數組移動到新數組中時是這樣的算法
key.hash & 15 e.hash & 31 hash值是一樣的 第二個參數不一樣 救過是不會變的哦。