前言
HashMap類可以說是集合類中最重要的一個，也是我們開發中經常用到的一個類。它底層實現涉及到一些比較有代表性的數據結構和算法。它本身也是在面試的時候被經常問到的。下面讓我們來詳細的學習一下吧！
HashMap介紹
其實在講集合之前，我們都應該先了解一下什麼是泛型？因爲在使用集合的時候，常常和泛型結合使用的。
泛型
泛型其實是在JDK1.5以後增加的， 本質就是“數據類型的參數化”。通俗理解就是數據類型的一個佔位符(形式參數)，其目的就是爲了告訴編譯器，在調用泛型時必須傳入實際類型。當然JDK也提供了支持泛型的編譯器，就是將運行時的類型檢查提前到了編譯時執行，提高了代碼可讀性和安全性。其實使用泛型爲程序員解決了很多麻煩，因爲泛型的作用還是比較明顯的。它可以校驗代碼、在使用了泛型的集合中，遍歷時就不必進行強制類型轉換、還有一點就是代碼的擴展性更強了。
泛型的使用其實非常簡單。比如，直接在類上加，其中的T，就像一個佔位符一樣表示“未知的某個數據類型”，我們在真正調用的時候傳入這個“數據類型”。我們常把T，K，E，V這三個當作泛型佔位符來使用。比如Map接口的定義源碼：
public interface Map<K,V> {
當然我們在使用泛型的時候也需要注意一些地方，比如說它只能使用引用類型，當它存在在有繼承關係的類之間是不能直接隱式向上造型的。
瞭解完泛型後，再來學習集合吧！HashMap其實是Map接口的一個實現，所以我們先來介紹一下map接口！
Map接口
Map就是用來存儲“鍵(key)-值(value) 對”的。 Map類中存儲的“鍵值對”通過鍵來標識，所以“鍵對象”是不能重複的。那麼我們判斷的依據是什麼呢？就是通過 equals方法來判斷的，如果出現重複的，它也不會報錯，只是會覆蓋之前的對象。Map接口下定義了一些常用的方法，如下：
Map 接口的實現類非常多，常用的有這些：HashMap、TreeMap、HashTable、Properties等。
下面就來詳細的學習一下HashMap。
HashMap
HashMap是採用哈希算法實現，是Map接口中最常用的實現類。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
由於底層採用了哈希表（這裏簡單解釋一下什麼是哈希表？就是數組+單向鏈表）存儲數據，我們要求鍵不能重複，如果發生重複，新的鍵值對會替換舊的鍵值對。 同時HashMap在查找、刪除、修改方面都有非常高的效率。這裏先給出結論，當你看了它的底層是怎麼實現，你也就清楚了。
HashMap底層實現
在學習HashMap底層之前，在這裏先拋出一些問題，這些問題會在下面一一接答的。
- 默認初始容量16和加載因子0.75有什麼作用？
- 數組有什麼作用，什麼時候創建數組？
- 鏈表有什麼作用？什麼時候形成鏈表？
- 紅黑樹有什麼作用？什麼時候形成紅黑樹？
- put方法的返回值爲什麼是被覆蓋的值？
- 怎麼去確定每一個entry在數組中存放的位置？
- 爲什麼key可以爲null？
上面已經說HashMap底層是由哈希表實現的。並且哈希表在jdk1.7的時候是基於數組+鏈表 ，在jdk1.8的時候基於數組+鏈表+紅黑樹。其實在HashMap中，是用Node類來存放鍵值對的，它是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;
}
其中key就是鍵對象，value就是值對象，next是指向下一個節點（這裏我們就可以看出這是一個單向鏈表），hash就是鍵對象計算出來的hash值。給大家提供一個比較形象的圖，方便理解。
前面我們說了哈希表是數組+單向鏈表或者再加紅黑樹，這裏的數組其實有個比較專業的名稱，叫做位桶數組。源碼如下：
transient Node<K,V>[] table;
可以看到它就是用來存放我們的Node對象的。那麼它是怎樣存放的呢？當然是通過put方法來實現的，所以我們就來重點看看put方法裏究竟做了些什麼？這裏帶領大家看看源碼，千萬不要被源碼嚇住，不一定是要每句都能看懂，但要知道它大概做了哪些事情。put方法源碼：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
看到put方法源碼，是不是很簡單啊！並不是多麼難以看懂。這裏put方法其實沒有做很多事情，就是計算了一下key的hash值和調用了putVal方法。來看看key的hash是怎麼計算的。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
這裏其實就是一個三目運算，當key爲null的時候，就直接返回0，不會null，就進行高位的與運算。看到這裏，上面提出的第7個問題是不是解決了。
下面讓我們繼續跟蹤putVal方法。
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;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> 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<K,V>)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;
}
不要看到這麼多的代碼就嚇住，其實一行一行的看，它是很簡單的。
首先聲明瞭幾個變量；
然後判斷了當前數組是否存在，通過這句代碼：if ((tab = table) == null || (n = tab.length) == 0)；如果不存在，調用resize方法創建數組；
接着根據int值和數組的最大索引值，計算當前entry在數組中存放的位置，並且判斷該位置是否已經存在entry ，if ((p = tab[i = (n - 1) & hash]) == null)，如果不存在，則直接創建一個新的node放在該位置，在這裏就解決了上面的第6個問題；
如果存在，就判斷key是否完全相同，通過equals方法，if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))，如果相同，則將該位置的node賦值給一個臨時的變量e， 方便最後返回被覆蓋的值，看到這上面的第5個問題解決了；
如果key不相同，則判斷是紅黑樹還是鏈表（else if (p instanceof TreeNode)），如果是紅黑樹，則以紅黑樹的方式存儲值，如果是鏈表，則以鏈表的方式存儲值；
然後判斷鏈表長度是否超過8（if (binCount >= TREEIFY_THRESHOLD - 1)），如果超過就轉換爲紅黑樹；
如果有被覆蓋的值（if (e != null)），最後返回被覆蓋的值；
最後判斷數組的使用長度是否已經超過加載因子所約定的長度（if (++size > threshold)），調用resize方法進行數組擴容 ，擴容爲原來的兩倍。
以上就是put方法所完成的事情，看過之後上面提出的問題也就迎刃而解了。這裏再介紹哈幾個HashMap裏定義的常量吧。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
其中DEFAULT_INITIAL_CAPACITY就表示數組的初始長度；DEFAULT_LOAD_FACTOR就是加載因子，用來判斷數組是否需要擴容；TREEIFY_THRESHOLD就表示鏈表的長度，如果大於8，就轉換爲紅黑樹；UNTREEIFY_THRESHOLD也是表示鏈表的長度，如果小於6，就轉換爲單向鏈表。爲什麼要轉換呢？因爲我們都知道鏈表查詢就是從頭遍歷到尾，如果你單向鏈表太長的話，查詢效率就會受到影響，此時再轉換爲紅黑樹，查詢效率就會好很多，同樣鏈表的長度如果小於6的話，鏈表查詢效率就會更好一些。
當你知道hashmap是怎麼存值後，再去看取值get方法，就會跟簡單了。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
這裏同樣也是一個三目運算，重點就是根據key計算int值後，調用了getNode方法。
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;
}
getNode方法還是先聲明瞭幾個變量；
然後判斷數組是存在，如果不存在，就直接返回null；
如果存在，就判斷該位置的第一個元素是否爲要找的元素 ，通過equals方法；
如果是，就直接返回；如果不是，就用紅黑樹或者鏈表的方式取值並返回。
區別
下面來總結一下map接口下常用實現類之間的區別：
-
HashMap: 線程不安全，但是效率較高。多數情況使用它，可以存在一個key爲null，多個value爲null 。
-
Hashtable: 線程安全，使用sychonized同步方法，效率低，key和value都不能爲null。
-
HashMap和Hashtable繼承類不同，實現接口相同。
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { -
ConcurrentHashMap：線程安全，同步的代碼塊，粒度比Hashtable更小 ，不能夠以null作爲key或者value 效率相對比Hashtable較高，它是通過把整個Map分爲N個Segment（類似HashTable），都是提供一樣的線程安全，但是這樣它的效率就會提升N倍，默認提升的是16倍。
-
Properties 是HashTable 的子類，主要用於讀取配置文件，只能存String，通過List 方法 Load方法進行讀取和寫入。