HashMap本质是一个链表散列的数据结构，即数组和链表的结合体。HashMap底层是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。
transient Entry[] table; static class Entry<K, V> implements Map.Entry<K, V>{ final K key; V value; Entry<K, V>next; final int hash; ..... }
put方法
先根据key算出hash值，然后根据得到的hash值来定位这个元素在数组中的位置，若数组该位置已经存放了其他元素，那么这个位置上的元素将以链表的形式存放，新加入的放在链表头，最先加入的放在链尾，如果数组在该位置没有元素，则将该元素放到数组中。
public V put(K key, V value){ if(key == null) return putForNullKey(value); int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); for(Entry<K, V> e = table[i]; e != null; ){ Object k; if(e.hash == hash && ((k = e.key) == key || key.equals(k))){ V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue； } } modCount++; addEntry(hash, key, value, i); return null; }
void addEntry(int hash, K key, V vaule, int bucketIndex){
Entry<K, V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K, V>(hash, key, value, e);
if(size ++ >= threshold)
resize(2 * table.length);
}
static int hash(int h){
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
static int indexFor(int h, int length){
return h & (length - 1);
}
get()方法：先根据key算出hash值，然后根据hash值找到对应位置的某一元素，然后通过key的equlas方法在对应位置的链表中找到需要的元素
public V get(Object key){ if(key == null) return getForNullKey(); int hash = hash(key.hashCode()); for(Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next){ Object k;
if(e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value; }
return null; }
当HashMap中的元素个数超过数组大小*loadFactor时，就会对数组进行扩容，扩大一倍后重新计算每个元素在数组中的位置。loadFactor的默认值是0.75。
loadFactor = 散列表的实际元素数目/散列表的容量。负载因子衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，若负载因子太大，对空间利用充分，但查找效率较低；若负载因子太小，那么散列表的数据将过于稀疏，对空间进行严重浪费。
threshold = (int) (capacity * loadFactor);超过threshold会重新resize，以降低实际的负载因子
java.util.HashMap是不安全的，若在使用迭代器的过程中有其他线程修改了map，则抛出ConcurrentModificationException，这是所谓的fail-fast策略。每次对HashMap内容的修改都将增加modCount域，在迭代器初始化过程中会将这个值赋给迭代器expectedModCount。
HashIterator(){ expectedModCount = modCount; if(size > 0) { Entry[] t = table; while(index < t.length && (next = t[index++]) == null) ; }
final Entry<K, V> nextEntry(){
if(modCount != expectedModCount)
throw new ConcurrentModificationException();
} }
在所有HashMap类的collection视图方法所返回的迭代器都是fail-fase的：在迭代器创建之后，若从结构上对映射进行修改，除非通过迭代器本身的remove方法，其他任何时间任何方式的修改，迭代器都会抛出ConcurrentModificationException。
JDK1.8改版HashMap
从结构实现上由数组+链表改为数组+链表+红黑树（当链表长度大于8时转换为红黑树）
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){...}
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;
}
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;
}
}
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;
if((p = tab[i = (n -1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else{
Node<K, V> e;
K k;
if(p.has == 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)
treeifyBin(tab, hash);
break;
}
if(e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if(e != null){
V oldValue = e.value;
if(!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if(++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
resize()：重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩容。Java的数组是无法自动扩容的，只好使用一个新的大的数组代替已有的容量小的数组。扩容时使用的是2次幂的扩展，因此元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。在JDK1.8中就无需重新计算hash，只需要看原来的hash值新增的那个bit是1还是0，是0的话索引没变，是1的话索引编程“原索引 + oldCap”。
final Node<K, V>[] resize(){
Node<K, V>[] 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;
}
}else if(oldThr > 0){
newCap = oldThr;
}else{
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", "uncheck"})
Node<K, V>[] newTab = (Node<K, V>[])new Node[newCap];
table = newTab;
if(oldTab != null){
for(int j = 0; j < oldCap; j++){
Node<K, V> e;
if(e.next == null)
newTab[e.hash & (newCap -1)] = e;
else if(e instanceof TreeNode)
((TreeNode<K, V>)e).split(this, newTab, j, oldCap);
else{
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){
loTail.next = null;
newTab[j] = loHead;
}
if(hiTail != null){
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
return newTab; }
get()方法
public V get(Object key){ Node<K, V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; }
final Node<K, V> getNode(int hash, Object key){
Node<K, V> tab;
if((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n -1) & hash]) != null){
if(first.hash == hast && ((k = first.ley) == 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;
}
