資料結構 5 雜湊表/HashMap 、自動擴容、多執行緒會出現的問題
阿新 • • 發佈:2020-03-15
上一節,我們已經介紹了最重要的B樹以及B+樹,使用的情況以及區別的內容。當然,本節課,我們將學習重要的一個數據結構、雜湊表
## 雜湊表
雜湊也常被稱作是散列表,為什麼要這麼稱呼呢,雜湊、雜湊、其元素分佈較鬆散、經常用來儲存例如`key-value`的資料、這樣有什麼好處呢?我們來細細琢磨一下:
- 公安 110
- 急救 120
- 火警 114
假設我們需要將這幾個資料儲存下來,並且取出的時候,我知道`公安` 我就能立馬查找出公安所對應的號碼。並且是快速查詢出?怎麼做呢?
我們都知道,陣列通過索引的方式,也就是下標,它的時間複雜度是最低的。O(1)
通過下標一下子就能找出來。我們有沒有辦法,通過我們當前的這個`key` 來算出hash 值呢?
這裡的`算` 這個過程,就是一個生成索引的過程,就是我們所說的`雜湊(hash)`
畫圖理解一下
![image.png](https://file.chaobei.xyz/blogs/image_1584021107048.png_imagess)
假設我們的Hash 演算法我們自己定義的,已知條件,所以我們隨便知道一個值`key` 就能算出這個值存在陣列的下標,所以呢 能夠實現快速查詢。
### 雜湊碰撞
就是兩個元素算出的hash值一樣呢?就會產生衝突,這樣的情況只能避免,不能消除。
![image.png](https://file.chaobei.xyz/blogs/image_1584021307779.png_imagess)
## HashMap
我們來看看JAVA 裡面的HashMap 是怎麼實現的吧;
```java
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
```
`DEFAULT_LOAD_FACTOR= 荷載係數` 預設是0.75 荷載比例大於這個數值的時候,就需要擴容了。
`DEFAULT_INITIAL_CAPACITY=初始化容量大小 16`
```java
transient Node[] table;
```
我們可以發現,它其中有一個table 的陣列,型別是Node,很顯然,這就是底層的陣列,放置的資料就是這個節點包裝類。
```java
Node(int hash, K key, V value, Node next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
```
節點帶有當前的hash值,以及鍵值、我們還會發現,他會帶有一個next 元素的指標,這說明什麼?就是單向連結串列唄。
### put 增加一個節點
我們構造一個新的map 集合,通過`put(k,v)` 向散列表中增加一個節點資訊。
```java
Map map = new HashMap<>();
map.put("key","value");
------------
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
```
我們得知,這個`hash(obj)` 方法將傳過來的key 通過運算得出hash 值。
`hashCode()` 是Object 類裡面的一個方法。
```java
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
```
這通常通過將物件的內部地址轉換為整數來實現,但Java的程式語言不需要此實現技術。
`說白了就是:將這個物件的記憶體地址通過一種整數的方式展現給我們。`
將得到的雜湊值進行 無符號右移 16位。 `>>>`
在與原來的雜湊值進行異或`^` 進行運算得出hash值。
### putVal()
```java
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node 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 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)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;
}
```
主要的元素填入是putVal()方法。我簡單說一下這個方法:
1. 通過傳入的hash 值確定這個元素將要放入的位置`i`
2. 確定`i`位置是否有元素
3. 若有元素。則通過連結串列的形式。`後入式插入`
4. 若沒有元素,則撇進去即可。
`後入式插入` 解釋一下這個詞:不要想歪啊,學術研究。
![image.png](https://file.chaobei.xyz/blogs/image_1584244401864.png_imagess)
![image.png](https://file.chaobei.xyz/blogs/image_1584244497462.png_imagess)
後面的元素則會替換原有的位置,後加入的元素下一個元素的指標指向原來的元素
### get()
```java
final Node getNode(int hash, Object key) {
Node[] tab; Node 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)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;
}
```
將HashMap 增加順序反過來即可。我們還是總結一下:
1. 通過傳入的`key`計算出雜湊值。 通過hash值確定這個元素原來存在的陣列下標位置`i`。
2. 訪問陣列指定位置`i`確定位置,這個元素存在與否。若存在則直接返回。
3. 若對比後發現不是這個元素。也沒有下一個元素的指標`next` 則返回null
4. 若存在下一個指標,則開始遍歷查詢。
### HashMap 長度
預設初始化長度為`16` 這個經常會被面試問到。還有一點就是:HashMap 的自動擴容或者手動指定長度。一般都是2的冪函式。 就是2的x次方。
為啥要選擇這樣,因為是和Hash 演算法有關。一般情況下。hash的值基本上都是由`key`的後幾位決定的。所以,這個就瞭解就可以了。不必要深究。
## 自動擴容
我們在上面涉及到一個 `DEFAULT_LOAD_FACTOR=荷載係數 `預設0.75
當底層陣列的大小不足以容納後面的元素的時候,就會發生擴容。也就是`resize()`
HashMap 主要涉及擴容的方法就是`resize()`
```java
final Node[] resize() {
Node[] 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[] newTab = (Node[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node 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)e).split(this, newTab, j, oldCap);
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node 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;
}
```
什麼時候會發生擴容呢?`當前容量>=總容量*荷載係數`
1. 建立一個新的陣列,建立一個新的陣列,長度是原來的2倍。
2. 遍歷`oldTab` 取出元素的鍵後,重新進行hash,算出`index=i = (newCap - 1) & hash`
3. 重新插入元素。
## 多執行緒下的HashMap
HashMap 在單執行緒下是安全的,但是不可用於多執行緒。
多執行緒下,HashMap 很容易形成`連結串列環`。這個記下來就可以了。
![image.png](https://file.chaobei.xyz/blogs/image_1584265117346.png_imagess)
`119` 的下一個元素指向`114`
而`114`的下一個元素又會指向`119` 這樣很容易形成死鎖
## 小結
通過本節,應該瞭解到一個重要的概念。雜湊,以及雜湊在JAVA 裡面涉及到的HashMap。而HashMap 幾個重要的概念,最後再次宣告一下:
1. HashMap 適用於單執行緒,多執行緒會出現死鎖(連結串列環)
2. HashMap 預設陣列大小 16 荷載係數 0.75
3. HashMap 在擴容的時候,擴容為本身的兩倍,並且重新進行put()
## 參考
https://mp.weixin.qq.com/s/HzRH9ZJYmidzW5j