作者：奮進的小樣 原文：https://www.cnblogs.com/fenjyang/p/11486403.html
一，前言
1.1，概述
現實生活中，我們常會看到這樣的一種集合：IP地址與主機名，身份證號與個人，系統用戶名與系統用戶對象等，這種一一對應的關係，就叫做映射（K-V）。Java提供了專門的集合類用來存放這種對象關係的對象，即java.util.Map接口。
-
Collection中的集合，元素是孤立存在的（理解爲單身），向集合中存儲元素採用一個個元素的方式存儲。 -
Map中的集合，元素是成對存在的(理解爲夫妻)。每個元素由鍵與值兩部分組成，通過鍵(K)可以找對所對應的值(V)。 -
Collection中的集合稱爲單列集合，Map中的集合稱爲雙列集合。 -
需要注意的是，
Map中的集合不能包含重複的鍵，值可以重複；每個鍵只能對應一個值。
通過查看Map接口描述，看到Map有多個子類，這裏我們主要講解常用的HashMap集合、LinkedHashMap集合。
-
HashMap<K,V>：存儲數據採用的哈希表結構，元素的存取順序不能保證一致。由於要保證鍵的唯一、不重複，需要重寫鍵的hashCode()方法、equals()方法。
-
LinkedHashMap<K,V>：HashMap下有個子類LinkedHashMap，存儲數據採用的哈希表結構+鏈表結構。通過鏈表結構可以保證元素的存取順序一致；通過哈希表結構可以保證的鍵的唯一、不重複，需要重寫鍵的hashCode()方法、equals()方法。
tips：Map接口中的集合都有兩個泛型變量<K,V>,在使用時，要爲兩個泛型變量賦予數據類型。兩個泛型變量<K,V>的數據類型可以相同，也可以不同。
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)在集合中存在，則返回值爲集合中鍵對應的值（該值爲替換前的值），並把指定鍵所對應的值，替換成指定的新值。
二，哈希表
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集合中的keySet<String> keySet = map.keySet();// 通過迭代器方式獲取key，先獲取一個迭代器Iterator<String> setIterator = keySet.iterator();while(setIterator.hasNext()){// 獲取keyString 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; // 保存節點的keyV value; // 保存節點的valueNode<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 1sttreeifyBin(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.75fif (++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是不是要找的Nodeif (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*oldCapelse if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)// 3，把新表的閾值設置爲舊錶閾值的兩倍，newThr=oldThr*2newThr = oldThr << 1; // double threshold}// 初始容量設置新的閾值else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;else { // zero initial threshold signifies using defaultsnewCap = 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;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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
在上一篇博客中總結了關於ArrayList集合的知識，後來打算想單獨寫一篇關於Hash Set的博客，但是想想和接下來要總結的Hash Map有些類似，因爲Hash Set底層就是通過Hash Map實現的。
從源碼看出這簡直是赤裸裸的new了一個Hash Map，雖然原理類似但多少有區別，畢竟這是兩個體系的集合。
最根本區別在於set集合存儲單值對象。而map是鍵值對，但有一個相同點是都不能存儲重複元素。
注意：Hash Set也是線程不安全的。
七，總結
關於集合的總結一共就兩篇，但是隻詳細總結了Array List和Hash Map兩個集合。那對於其他的爲什麼沒有詳細總結，因爲博主覺得剩下的基本是大同小異，比如Hash Set和Hash Map的關係。所以只把兩個派系的典型集合總結完畢，但是每個集合之間都是有區別的，在工作中也要根據實際情況選擇。
另外關於集合方面的知識也是面試中常問的，後期會整理一些關於面試方面的題共大家參考。
最後關於集合總結就這些，但這只是開始，還有很多集合方面的內容沒有總結，因此後期還會繼續更新。以上內容都是自主學習整理，如有不適之處，歡迎留言指正。
感謝閱讀！