Map的底層實現原理
一，前言
1.1，概述
現實生活中，咱們常會看到這樣的一種集合：IP地址與主機名，身份證號與我的，系統用戶名與系統用戶對象等，這種一一對應的關係，就叫作映射（K-V）。Java提供了專門的集合類用來存放這種對象關係的對象，即java.util.Map接口。html
Collection中的集合，元素是孤立存在的（理解爲單身），向集合中存儲元素採用一個個元素的方式存儲。Map中的集合，元素是成對存在的(理解爲夫妻)。每一個元素由鍵與值兩部分組成，經過鍵(K)能夠找對所對應的值(V)。Collection中的集合稱爲單列集合，Map中的集合稱爲雙列集合。- 須要注意的是，
Map中的集合不能包含重複的鍵，值能夠重複；每一個鍵只能對應一個值。
經過查看Map接口描述，看到Map有多個子類，這裏咱們主要講解經常使用的HashMap集合、LinkedHashMap集合。java
- HashMap<K,V>：存儲數據採用的哈希表結構，元素的存取順序不能保證一致。因爲要保證鍵的惟1、不重複，須要重寫鍵的hashCode()方法、equals()方法。
- LinkedHashMap<K,V>：HashMap下有個子類LinkedHashMap，存儲數據採用的哈希表結構+鏈表結構。經過鏈表結構能夠保證元素的存取順序一致；經過哈希表結構能夠保證的鍵的惟1、不重複，須要重寫鍵的hashCode()方法、equals()方法。
tips：Map接口中的集合都有兩個泛型變量<K,V>,在使用時，要爲兩個泛型變量賦予數據類型。兩個泛型變量<K,V>的數據類型能夠相同，也能夠不一樣。node
1.2，經常使用方法
Map接口中定義了不少方法，經常使用的以下：數組
public V put(K key, V value): 把指定的鍵與指定的值添加到Map集合中。public V remove(Object key): 把指定的鍵 所對應的鍵值對元素 在Map集合中刪除，返回被刪除元素的值。public V get(Object key)根據指定的鍵，在Map集合中獲取對應的值。boolean containsKey(Object key)判斷集合中是否包含指定的鍵。public Set<K> keySet(): 獲取Map集合中全部的鍵，存儲到Set集合中。public Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中全部的鍵值對對象的集合(Set集合)。
tips:安全
1，使用put方法時，若指定的鍵(key)在集合中沒有，則沒有這個鍵對應的值，返回null，並把指定的鍵值添加到集合中；數據結構
2，若指定的鍵(key)在集合中存在，則返回值爲集合中鍵對應的值（該值爲替換前的值），並把指定鍵所對應的值，替換成指定的新值。app
二，哈希表
Map的底層都是經過哈希表進行實現的，那先來看看什麼是哈希表。函數
JDK1.8以前，哈希表底層採用數組+鏈表實現，即便用鏈表處理衝突，同一hash值的鏈表都存儲在一個鏈表裏。可是當位於一個桶中的元素較多，即hash值相等的元素較多時，經過key值依次查找的效率較低。性能
JDK1.8中，哈希表存儲採用數組+鏈表+紅黑樹實現，當鏈表長度超過閾值（8）時，將鏈表轉換爲紅黑樹，這樣大大減小了查找時間。以下圖（畫的很差看，只是表達一個意思。）：優化
說明：
1，進行鍵值對存儲時，先經過hashCode()計算出鍵（K）的哈希值，而後再數組中查詢，若是沒有則保存。
2，可是若是找到相同的哈希值，那麼接着調用equals方法判斷它們的值是否相同。只有知足以上兩種條件才能認定爲相同的數據，所以對於Java中的包裝類裏面都重寫了hashCode()和equals()方法。
JDK1.8引入紅黑樹大程度優化了HashMap的性能，根據對象的hashCode和equals方法來決定的。若是咱們往集合中存放自定義的對象，那麼保證其惟一，就必須複寫hashCode和equals方法創建屬於當前對象的比較方式。
下面說說關於hashCode()和equals()方法。
2.1，hashCode()和equals()
關於hashCode()咱們先來看看API文檔的解釋。
再來看equals()的API解釋：
總結：經過直接觀看API文檔中的解釋，在結合哈希表的特色。咱們得知爲何要使用hashCode()方法和equals()方法來做爲元素是否相同的判斷依據。
1，使用hashCode()方法能夠提升查詢效率，假如如今有10個位置，存儲某個元素若是說沒有哈希值的使用，要查找該元素就要所有遍歷，在效率上是緩慢的。而經過哈希值就能夠很快定位到該元素的位置，節省了遍歷數組的時間。
2，可是經過哈希值就能肯定惟一的值嗎，固然不是。所以才須要使用equals再次進行判斷。判斷的目的在於當元素哈希值相等時，使用equals判斷它們究竟是不是同一個對象，若是是則表明是同一個元素，不然不是同一個元素那麼就將其保存到鏈表上。
所以哈希值的使用就是爲提升查詢速度，equals的使用就是判斷對象是否爲重複元素。
2.2，Map遍歷方式
在文章上面講述到，map保存的是鍵值對形式，也就是說K和V的類型有多是不同的，也有多是自定義的對象。所以不能像使用普通for循環遍歷集合去遍歷map集合。別急，在Map中已經爲咱們提供的兩種方式，keySet()和entrySet()。
1，keySet()方式
經過該方法能夠獲取map中的所有key，返回的是一個set集合。那麼獲取到map中的key難道還拿不到對應的value嗎。請看以下代碼：
Map<String,Object> map = new HashMap<>(); map.put("Hello","World"); map.put("你好","世界"); // 1，經過ketSet方式獲取map集合中的key Set<String> keySet = map.keySet(); // 經過迭代器方式獲取key，先獲取一個迭代器 Iterator<String> setIterator = keySet.iterator(); while(setIterator.hasNext()){ // 獲取key String keyMap = setIterator.next(); Object obj = map.get(keyMap); System.out.println("map--->"+obj); } // 2，使用加強for遍歷set集合 for(String key : keySet){ System.out.println(map.get(key)); } // 簡化for循環 for(String key : map.keySet()){ System.out.println(map.get(key)); }
2，entrySet()
咱們已經知道，Map中存放的是兩種對象，一種稱爲key(鍵)，一種稱爲value(值)，它們在在Map中是一一對應關係，這一對對象又稱作Map中的一個Entry(項)。Entry將鍵值對的對應關係封裝成了對象。即鍵值對對象，這樣咱們在遍歷Map集合時，就能夠從每個鍵值對（Entry）對象中獲取對應的鍵與對應的值。
既然Entry表示了一對鍵和值，那麼也一樣提供了獲取對應鍵和對應值得方法：
public K getKey()：獲取Entry對象中的鍵。public V getValue()：獲取Entry對象中的值。
在Map集合中也提供了獲取全部Entry對象的方法：
public Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中全部的鍵值對對象的集合(Set集合)。
// 使用Entry鍵值對 Set<Map.Entry<String, Object>> entrySet = map.entrySet(); // 1，使用迭代器 Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator(); while(iterator.hasNext()){ Map.Entry<String, Object> entry = iterator.next(); System.out.println(entry.getKey()+"--->"+entry.getValue()); } System.out.println("============================="); // 2，使用for循環遍歷 for(Map.Entry<String,Object> entry : map.entrySet()){ System.out.println(entry.getKey()+"--->"+entry.getValue()); }
三，Hash Map實現原理
3.1，常量的使用
//建立 HashMap 時未指定初始容量狀況下的默認容量 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //HashMap 的最大容量 static final int MAXIMUM_CAPACITY = 1 << 30; //HashMap 默認的裝載因子,當 HashMap 中元素數量超過 容量裝載因子時，進行resize()操做,至爲何是0.75，官方說法是這個值是最佳的閾值。 static final float DEFAULT_LOAD_FACTOR = 0.75f; //用來定義在哈希衝突的狀況下，轉變爲紅黑樹的閾值 static final int TREEIFY_THRESHOLD = 8; // 用來肯定什麼時候將解決 hash 衝突的紅黑樹轉變爲鏈表 static final int UNTREEIFY_THRESHOLD = 6; /* 當須要將解決 hash 衝突的鏈表轉變爲紅黑樹時，須要判斷下此時數組容量，如果因爲數組容量過小（小於 MIN_TREEIFY_CAPACITY ）致使的 hash 衝突太多，則不進行鏈表轉變爲紅黑樹操做，轉爲利用 resize() 函數對 hashMap 擴容 */ 17 static final int MIN_TREEIFY_CAPACITY = 64;
3.2，node節點類
// Node是單向鏈表，它實現了Map.Entry接口而且實現數組及鏈表的數據結構 static class Node<k,v> implements Map.Entry<k,v> { final int hash; // 保存元素的哈希值 final K key; // 保存節點的key V value; // 保存節點的value Node<k,v> next; // 鏈表中，指向下一個鏈表的節點 //構造函數Hash值 鍵 值 下一個節點 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; } //重寫equals方法，與咱們上文中講述的原理 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; }
3.3，紅黑樹源碼
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // 定義紅黑樹父節點 TreeNode<K,V> left; // 左子樹 TreeNode<K,V> right; // 右子樹 TreeNode<K,V> prev; // 上一個節點，後期會根據上一個節點做相應判斷 boolean red; // 判斷顏色的屬性 TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } /** * 返回根節點 */ final TreeNode<K,V> root() { for (TreeNode<K,V> r = this, p;;) { if ((p = r.parent) == null) return r; r = p; } }
3.4，構造函數
第一種構造函數，指定初始化容量大小及裝載因子。
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 }
3.5，put方法
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; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 1，若是table的在（n-1）&hash的值是空，就新建一個節點插入在該位置 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); // 2，不然表示有衝突,開始處理衝突 else { Node<K,V> e; K k; // 3，接着檢查第一個Node，p是否是要找的值 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) { // 4，若是指針爲空就掛在後面 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } // 5，若是有相同的key值就結束遍歷 if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } // 6，就是鏈表上有相同的key值 if (e != null) { // existing mapping for key，就是key的Value存在 V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue;//返回存在的Value值 } } ++modCount; // 7,若是當前大小大於定義的閾值，0.75f if (++size > threshold) resize();//擴容兩倍 afterNodeInsertion(evict); return null; }
3.6，get方法
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } // 1，經過哈希值和key查找元素 final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab;//Entry對象數組 Node<K,V> first,e; int n; K k; // 2，找到插入的第一個Node，方法是hash值和n-1相與，tab[(n - 1) & hash] // 表示在一條鏈上的hash值相同的 if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) { // 3，檢查第一個Node是否是要找的Node if (first.hash == hash && // always check first node // 4，判斷條件是hash值要相同，key值要相同 ((k = first.key) == key || (key != null && key.equals(k)))) return first; // 5，檢查下一個元素 if ((e = first.next) != null) { if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); // 6，遍歷後面的鏈表，找到key值和hash值都相同的Node節點 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }
3.7，擴容機制
hashmap擴容是一件相對很耗時的事情，在初始化hash表結構時，若是沒有指定大小則默認爲16，也就是node數組的大小。當容量達到最大值時，擴容到原來的2倍。
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; // 1，判斷舊錶的長度不是空，且大於最大容量 if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } // 2，把新表的長度設置爲舊錶長度的兩倍，newCap=2*oldCap else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) // 3，把新表的閾值設置爲舊錶閾值的兩倍，newThr=oldThr*2 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"}) // 4，建立新的表，並初始化原始數據 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab;//把新表賦值給table // 原表不是空要把原表中數據移動到新表中 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)//說明這個node沒有鏈表直接放在新表的e.hash & (newCap - 1)位置 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) {//lo隊不爲null，放在新表原位置 loTail.next = null; newTab[j] = loHead; } if (hiTail != null) {//hi隊不爲null，放在新表j+oldCap位置 hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
map集合的擴容要比list集合複雜的多。
四，Linked Hash Map
對於LinkedHashMap而言，它繼承與HashMap、底層使用哈希表與雙向鏈表來保存全部元素。其基本操做與父類HashMap類似，它經過重寫父類相關的方法，來實現本身的連接列表特性，同時它也保證元素是有序的。
五，Hash Table
Hashtable的實現原理和Hash Map是相似的，但區別是它是線程安全的，也正由於如此致使查詢速度較慢。
注意：Hash Table中K和V是不容許存儲null值。
六，Hash Set
Hash Set底層就是經過Hash Map實現的。
從源碼看出這簡直是赤裸裸的new了一個Hash Map，雖然原理相似但多少有區別，畢竟這是兩個體系的集合。
最根本區別在於set集合存儲單值對象。而map是鍵值對，但有一個相同點是都不能存儲重複元素。
注意：Hash Set也是線程不安全的。
相關文章
- 1. MAP的底層原理
- 2. Map底層實現
- 3. 從底層理解 Golang 的 map 實現
- 4. KVO 底層實現原理
- 5. synchronized底層實現原理
- 6. malloc底層原理實現
- 7. AutoreleasePool底層實現原理
- 8. Vue底層實現原理
- 9. SpringBoot底層實現原理
- 10. AES底層原理實現
- 更多相關文章...
- • MyBatis的工作原理 - MyBatis教程
- • 現實生活中的 XML - XML 教程
- • ☆基於Java Instrument的Agent實現
- • Java Agent入門實戰（三）-JVM Attach原理與使用
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. MAP的底層原理
- 2. Map底層實現
- 3. 從底層理解 Golang 的 map 實現
- 4. KVO 底層實現原理
- 5. synchronized底層實現原理
- 6. malloc底層原理實現
- 7. AutoreleasePool底層實現原理
- 8. Vue底層實現原理
- 9. SpringBoot底層實現原理
- 10. AES底層原理實現