【HashMap】1.8源码分析（一）
一、HashMap的基本常识：
1、HashMap是基于hash（哈希）算法进行操作的，Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。（百度百科）
2、HashMap的数据结构是：桶+链表（或红黑树）
二、基本属性
//Map默认的初始容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的加载因子，可以通过构造函数修改
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转换成红黑树的阀值，当链表长度达到8的时候，开始抓换成红黑树，这个概念是JDK1.8(包含)之后才引入的概念
static final int TREEIFY_THRESHOLD = 8;
//红黑树退化成链表的阀值
static final int UNTREEIFY_THRESHOLD = 6;
//红黑树的最大容量
static final int MIN_TREEIFY_CAPACITY = 64;
//链表节点
transient Node[] table;
//
transient Set> entrySet;
//HashMap的长度
transient int size;
//修改次数
transient int modCount;
//阀值
int threshold;
//加载因子
final float loadFactor;
上面是HashMap的基本属性，其中有几点需要讲解的：
1、其中 1 << 4 表示0000 0001中的最左边的1向左移动4位变成0001 0000，转换成10进制是16，就是2的4次方。
2、链表转换成红黑树和红黑树退化链表的阀值为什么是8和6，可能的原因就是根据统计发现8和6是最合适的，为什么不是相同的呢？想象一下，如果是相同的，就会频繁的把链表和红黑树转换，造成性能的让费，设计成不同的有一个缓冲的区域，不至于频繁转换(在一篇博客上面看到的，借用了)。
三、构造方法
//构造函数-入参（初始容量，加载因子）
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;
//返回一个2的次方整数
this.threshold = tableSizeFor(initialCapacity);
}
//构造函数-入参（初始容量）
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//无参构造函数
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//构造函数- 入参（Map结构）
public HashMap(Map m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
上面是HashMap的构造方法，默认的无参构造函数，初始容量是16，加载因子是0.75f，如果有自己的需求，可以调用不同的构造函数，有一点要说明的，HashMap的构造函数，并没有初始化桶（数组），除了入参是Map结构的。
三、put功能实现
//空壳方法，调用putVal方法
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[] tab; Node p; int n, i;
//如果talbe为null或者table的size==0；就需要初始化
if ((tab = table) == null || (n = tab.length) == 0)
//初始化方法或者扩容resize()，此方法在下面讲解
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//如果数组的第一个元素为null，直接新增放到第一个位置
tab[i] = newNode(hash, key, value, null);
else {
//下面是发生了碰撞的场景：
Node e; K k;
//第一种情况：首接单相同的hash和key，直接覆盖原来的节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
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);
//当前节点大于等于8，则转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
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;
举几个例子介绍一下(h = key.hashCode()) ^ (h >>> 16)和tab[i = (n - 1) & hash]
第一个例子：key = "abc"
96354^96354>>>16
10111100001100010^0000000000000001=10111100001100011(96355)
96355&1111
10111100001100011&1111 = 0011(3)
第二个例子：key = "123"
48690^48690>>>16
1011111000110010^0000000000000001=1011111000110011(48691)
1011111000110011 & 1111 = 0011(3)
第三个例子：key = "54654654654654645"
-1504435976 ^ -1504435976>>>16
01011001101010111101111100001000(原码)
10100110010101000010000011110111（反码）
10100110010101000010000011111000 （补码）
10100110010101000010000011111000 ^ 00000000000000001010011001010100 = 10100110010101001000011010101100(-1504409940)
10100110010101001000011010101100(补码)
10100110010101001000011010101011(补码)
01011001101010110111100101010100（原码）
10100110010101001000011010101100 & 1111 = 1100(12)四、get功能实现
//空壳方法，调用getNode()方法
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node getNode(int hash, Object key) {
Node[] tab; Node first, e; int n; K k;
//数组不为空，数组的长度大于0，key的hash在数组中的位置要有数据
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)first).getTreeNode(hash, key);
do {
//第三种，循环比较链表中的key，直到数组的下一个节点为空
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
} 五、resize扩容机制
final Node[] resize() {
//新建一个数组，存放旧的数组
Node[] 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;
}
// oldCap << 1的意思是二进制位向左移动一位，相当于乘以2
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
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","unchecked"})
Node[] newTab = (Node[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//循环旧的数组，
for (int j = 0; j < oldCap; ++j) {
Node e;
//旧的数组节点不为空，分三种情况处理数据
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode)e).split(this, newTab, j, oldCap);
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node 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;
}
以上是HashMap1.8的基本源码，只是在代码中做了一下注释，比较简单，详细的分析比如二叉树和链表的转换，数组的扩容方法，会再出一期，自己学习做个记录，如果有错误的地方，可以交流一下。