1.HashMap怎麼實現hashcode和equals
HashMap的資料結構是連結串列+陣列，HashMap的資料結構類似於：
元素0->[hashCode=0,key.value=x1的資料]
元素1->[hashCode=1,key.value=y1的資料]
...
元素n->[hashCode=n,key.value=n1的資料]複製程式碼hashMap的put和get方法都會呼叫hashCode方法，如果兩個hashCode有衝突，再呼叫equals方法:
put()：會呼叫物件的hashCode()方法來計算hashcode，然後找到buchet（桶）位置來儲存物件，當獲取物件時，通過鍵物件的equals()方法找到正確的鍵值對，然後返回值物件。hashMap通過連結串列來解決衝突問題，如果發生碰撞，物件就會儲存在連結串列的下一節點。
get()：buchet（桶）裡的第一個節點，直接命中；如果有衝突，則通過key.equals(k)去找對應的可以。
為什麼要重寫hashCode()和equals()：
首先先來看一下equals:
public boolean equals(Object obj){
return (this==obj);
}複製程式碼是通過==來比較兩個物件的引用地址，Object的equals只是簡單的判斷是不是同一個例項，但如果我們需要比較邏輯上的相等，就需要重寫equals()方法，而涉及到HashMap的時候，重寫了equals()就需要重寫hashCode()方法。
2.concurrentHashMap怎麼實現
採用了“分段鎖”的方式來確保線性安全，相比於HashTable，不會存在鎖競爭，可以有效的提高併發效率。
concurrentHashMap的主幹是Segment陣列
final Segment<K,V>[] segment;複製程式碼Segment繼承了ReentrantLock，所以它就是一種“可重入鎖”。在concurrentHashMap中一個Segment就相當於一個子雜湊表，Segment裡維護了一個HashEntry陣列，在併發情況下，不需要考慮鎖的競爭。
#Segment:
transient volatile HashEntry<K,V>[] table;複製程式碼一個ConcurrentHashMap維護一個Segment，一個Segment維護一個HashEntry，對於同一個Segment才考慮執行緒同步，不同Segment不需要考慮。
jdk7中：
put()：1.定位segment並確保定位的Segment已初始化 2.呼叫Segment的put方法
get()：get無需加鎖，由於其涉及的共享變數都使用volatile修飾，volatile可以保證記憶體可見性，所以不會讀取過期資料。
jdk8中：
put()：沿用了hashMap中的put，根據hash值計算這個新插入的點在table中的位置i，如果i位置是空的，直接放進去，否則進行判斷，如果i位置是樹節點，按照樹的方式插入新的節點，否則把i插入到連結串列的末尾，但是不允許key或value為null。
呼叫的是putVal方法
public V put(K key, V value) { return putVal(key, value, false);}複製程式碼final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());// 計算key的hash值
int binCount = 0;// 表示table中索引下標代表的連結串列或紅黑樹中的節點數量
// 採用自旋方式，等待table第一次put初始化完成，或等待鎖或等待擴容成功然後再插入
for (Node<K,V>[] tab = table;;) {
// f節點標識table中的索引節點，可能是連結串列的head，也可能是紅黑樹的head
// n:table的長度，i:插入元素在table的索引下標，fh : head節點的hash值
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)// 第一次插入元素，先執行初始化
tab = initTable();
// 定位到的索引下標節點(head)為null，表示第一次在此索引插入，
// 不加鎖直接插入在head之後，在casTabAt中採用Unsafe的CAS操作，保證執行緒安全
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// head節點為ForwadingNode型別節點，表示table正在擴容，連結串列或紅黑樹也加入到幫助擴容操作中
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {// 索引下標存在元素，且為普通Node節點，給head加鎖後執行插入或更新
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {// 為普通連結串列節點，還記得之前定義的幾種常量Hash值嗎？
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
// 插入新元素，每次插在單向連結串列的末尾，這點與Java7中不同（插在首部）
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key, value, null);
break;
}
}
}
else if (f instanceof TreeBin) {// head為樹節點，按樹的方式插入節點
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
// 連結串列節點樹超過閾值8，將連結串列轉換為紅黑樹結構
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 如果是插入新元素，則將連結串列或紅黑樹最新的節點數量加入到CounterCells中
addCount(1L, binCount);
return null;
}複製程式碼get()：
1、計算key的hash值，並定位table索引2、若table索引下元素(head節點)為普通連結串列，則按連結串列的形式迭代遍歷。
3、若table索引下元素為紅黑樹TreeBin節點，則按紅黑樹的方式查詢(find方法)。
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {// 普通連結串列
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// hash值小於-1,即為紅黑樹，還記得之前定義的TreeBin節點的hash值嗎
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {// 匹配下一個連結串列元素
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}複製程式碼3.volatile
volatile實現的是可見性，即一個執行緒的修改對另一個執行緒是可見的。也就是一個執行緒修改結果，另一個執行緒馬上能看到。
當把變數宣告為volatile型別後，編譯器與執行時都會注意到這個變數是共享的，因此不會將該變數上的操作與其他記憶體操作一起重排序，在訪問volatile變數時不會執行加鎖操作，因此也就不會使執行執行緒阻塞，因此volatile變數是一種比sychronized關鍵字更輕量級的同步機制。