几个重要的成员变量：
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量
/**
* 构造函数中没有指明负载因子的时候默认为0.75
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 数化的阈值
static final int TREEIFY_THRESHOLD = 8;
// 退化为链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 可对桶进行树型化（变为红黑树）的最小表容量。
*（否则，如果一个桶中的节点太多，则会调整表的大小。）
* 应至少为4*TREEIFY_THRESHOLD，以避免调整大小和树调整阈值之间的冲突。
*/
static final int MIN_TREEIFY_CAPACITY = 64; // 链表变为红黑树时数组容量的最小值
// resize 的阈值 (capacity * load factor).
int threshold;HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Node(jdk 1.7 中为Entry)。
transient Node[]table;
static class Node implements Map.Entry {
final int hash;
final K key;
V value;
Node next;
consrtuctor;
Getter /setter ;
hashCode;
equals;
...
} 常使用的是两个方法：Get 和 Put。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}put 和putIfAbsent 的区别就在于传入的一个参数（onlyIfAbsent）的不同。也就是putIfAbsent方法插入数据的时候，如果没有出现过这个值，就插入，出现过这个值就不覆盖，不写入。put方法在插入数据时，如果出现过，直接覆盖之前的数据。
Java8之前是头插法，就是说新来的值会取代原有的值，原有的值就顺推到链表中去。Java7 的时候是采用头插法，但是在多线程的情况下会出现死循环的情况。
Jdk1.8开始采用尾插法
Put()方法的过程：
例如 map.put("key01","value01");
刚开始，如果tab 是空的或者表长度为0，就会对tab 进行扩容。
然后根据key的 hash 值去计算key 在tab 中的下标。(n - 1) & hash。我们将计算的结构记为i，即tab[i]代表当前节点。如果tab[i]为null ，那么直接将该节点插入这个位置。
如果不是相同的节点，它就会判断书否为一个红黑树的节点，如果是的话，就将该节点插入红黑树。
如果不是红黑树的节点，那么会遍历整个链表，并判断是否存在和当前节点（key）相同的节点，如果存在相同的节点，那么将这个节点的value 覆盖之前的,并且会检查当前链表的大小，如果大于阈值，会将这个链表进行树化，变为一颗红黑树。最后会对这个tab的大小进行检查，看增加节点后的tab 是否需要进行扩容，这个阈值等于容量乘负载因子。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node[] tab;
Node p;
int n, i;
// 如果tab为空或者长度为0 ，则resize()扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 计算index
if ((p = tab[i = (n - 1) & hash]) == null)
// tab[i]为null，直接插入
tab[i] = newNode(hash, key, value, null);
else {
// tab[i]不为空的情况下
Node e; K k;
// 判断tab[i]的key.hash是否和当前插入节点的key的hash相等
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
// e 节点指向tab[i]，也就是p
e = p;
// 如果不相等，判断是否是一个树节点
else if (p instanceof TreeNode)
// 是一个树节点，那么将这个节点插入这可红黑树中
e = ((TreeNode)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
// 对tab进行树化
treeifyBin(tab, hash);
break;
}
// 判断两个节点的key是否相同，相同则跳出循环
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;
} 为啥tab 的大小必须为2的n次的幂
为啥是这样算的呢？因为
计算出来的hash值有些不在tab 中，为了映射到tab中，就需要对hash值进行取模运算，即 hash%n。当n为2的幂的时候，hash%n 就等于 (n - 1) & hash 了。采用二进制位操作 &，相对于%能够提高运算效率， 这也就是为什么tab 的长度为2的幂了。
举例:
若 a = 10 , b = 8 , 10与8取余应得2.
8的二进制为: 1000 ; 7的二进制为: 0111.
10---> 1011
7 ---> 0111
1011
0111
0011
resize（） 方法这篇文章不错-->深入理解HashMap(四): 关键源码逐行分析之resize扩容