上一篇，做了一下准备工作，分析了一下Map接口和AbstractMap类的源码，现在正式开始分析HashMap的源码。
HashMap底层是一个散列表+红黑树结构，所谓散列表结构，就是(数组+链表)，为什么会有红黑树结构呢？jdk1.8之后，HashMap的磁层添加了红黑树结构，在一个条件下，可以将散列表转化为红黑树结构。
先看一下HashMap类的定义，
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
——HashMap中的节点结构
/*
内部类，底层就是一个实现Map类中的Entry类
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//把key值经过hash()方法，得到一个值为hash，根据这个值去找数组的下标，如果对应上了，就在这个数组的
final K key;//key值
V value;//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;
}
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;
}
}
成员变量hash的值，其实是key经hash算法，得到一个0--15的一个值，对应初始化的数组(数组容量16)的下标。这里大家可以网上搜索一下，具体了解一下。
——HasHMap的成员变量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16 数组的初始容量，就是一个数组的长度为16
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量 2的31次方
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认装填因子
static final int TREEIFY_THRESHOLD = 8;//同一个桶中至少已经有了TREEIFY_THRESHOLD个节点，在添加一个元素，此时会将链表结构转化为树形结构
static final int UNTREEIFY_THRESHOLD = 6;//untrrrify_threshold 同上，将树形结构转化成链表结构
static final int MIN_TREEIFY_CAPACITY = 64;//桶可能被转化为树形结构的最大容量
transient Node<K,V>[] table;//数组，散列表底层就是数组和链表，
transient Set<Map.Entry<K,V>> entrySet;//Map的key-value映射对放到set集合中
transient int size;//映射的长度
transient int modCount;//操作次数
int threshold;//所能容纳映射对数的极限，HashMap 的容量乘以负载因子，threshold=size*DEFAULT_LOAD_FACTOR
final float loadFactor;//负载因子，我们自己可以设置负载因子
——HasHMap的构造方法(4个)
/*
第一个参数，是指定hashMap的容量，第二个参数指定负载因子
*/
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))//NaN：Not a Number，一种不确定的数字，判断传入的参数是否合法
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);//这里调用了一个tableSizeFor(),请看下面讲解
}
/*
指定了容量，其实就是调用了HashMap(int initialCapacity, 默认装填因子)
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);//调用的是第一个构造器，只是负载因子使用的是默认的
}
/*
无参构造，构建一个初始容量为 16，负载因子为 0.75 的 HashMap
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/*
参数是一个Map集合，最后在看这个构造方法吧，因为调用了putMapEntries()方法，后面会讲到。
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;//默认装填因子
putMapEntries(m, false);
}
在第一个构造方法中调用了tableSizeFor()方法，这个方法有什么用呢？
:传入一个指定的容量值，返回一个大于传入的参数且最接近2的整数次幂的数，如传入的是5，返回的是8(2的3次方)
传入的是9，返回的时16(2的4次方)
static final int tableSizeFor(int cap) {//cap为我们指定的容量值
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
——HasHMap的获得节点(获得链表中的一个节点)，因为有很多方法都会调用此方法。
/*
获得一个节点，链表结构，就是一个一个Node节点连接而成的 Node(int hash, K key, V value, Node<K,V> next)
*/
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) {
//判断数组不为null，并且根据key值定位到的桶不为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) {
//如果第一个节点不等于你要获得的节点，并且下一个节点不为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;
}
中间据判断是否为红黑树结构，因为HashMap会将链表结构转变为红黑树结构，在这里先不讲解HashMap为红黑树结构的这一种情况。
重头戏来了哦。
——HasHMap的添加节点
/*
添加一个元素
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);//调用了putVal()方法
}
/*
和以一个集合为参数的构造方法，底层是一样，都是调用putMapEntries方法，如果可以容乃，就添加，容纳不下，扩容，最后遍历数组，多次调用put方法
*/
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);//调用了putMapEntrise()方法，在一个参数是一个Map集合的构造器中，也调用了该方法
}
/*
与put方法的区别在与 putIfAbsent方法添加时，如果存在相同的key，不会替换
而put方法添加时，如果key相同时，会替换
*/
@Override
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}
调用了putVal()方法，我们来看一下这个方法的源码。
/*
添加元素的实际方法，添加元素，需要先查看相同的位置有没有存在节点，如果右节点，之际替换value
*/
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)
/*
hash&(length-1)此操作得到的是要把该节点插入到数组的哪个下标元素上
这个下标的元素为null，添加映射时，直接赋值即可
*/
tab[i] = newNode(hash, key, value, null);//因为这个桶中没有节点，所以直接在这个桶中添加
else {
//如果不为null，这个桶中有节点
Node<K,V> e;
K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
/*
如果位置相等，并且key值相等，直接覆盖，需要覆盖时，都是讲新节点赋予节点e，因为下面有一个if语句，判断e的值，然后
改变的仅仅是e的value值
*/
e = p;
else if (p instanceof TreeNode)
/*
如果p是红黑树结构，
*/
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//定位到这个捅了，是链表结构，没有进行树化，并且在这个桶中没有找到key值相同的节点
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//如果该节点的next为空(这个桶中只有一个节点)，直接在该节点的后面插入节点
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st一条链表的节点数超过8，进行树化
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
/*
下一个节点不是null，并且已经找到该节点了，跳出循环
*/
break;
p = e;//其实是 e=p.next,p=e;来控制链表后移的
}
}
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//添加节点时，onlyIfAbsent为false
//putIfAbsent方法的onlyIfAbsent为true，不会替换值e.value = value; afterNodeAccess(e);//空实现，空方法，没有任何作用 return oldValue; } } ++modCount; if (++size > threshold) //size大于节点最大值，扩容 resize(); afterNodeInsertion(evict); return null; }
然后我们来看一下putMapEnyries()方法的源码。
/*
将一个Map集合添加到HashMap中
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
//判断要插入的集合是否不为空
if (table == null) { // pre-size
//判断这个散列表是否为空，为空时，要初始化一个HashMap
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);//略大于t的2的幂次方
}
else if (s > threshold)
//所能容纳的极限不足以容纳m集合，需要扩容
resize();//扩容
//最后一步，都是要添加数据的
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
//遍历，然后插入数据
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
好了添加方法，我们已经分析完成了，其中添加时，如果容量较小时，会进行扩容操作resize()方法。其实，扩容操作也是很重要的。
——HasHMap的扩容操作(希望大家重点看一下)
/*
该方法具有扩容数组，和初始化数组的功能
*/
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldCap等于table数组的长度，table为null时，oldCap为0
int oldThr = threshold;//所能容纳的极限，有两个构造方法都指定了HashMap的容量，然后根据一个方法，计算出threshold，2的n次方略大于指定的容量
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
//如果table的长度已经超过了规定的最大长度
threshold = Integer.MAX_VALUE;//将threshold设置为Integer能表达的最大值
return oldTab;//返回Table
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//oldCap*2小于最大，大于默认值，此时要进行扩容
newThr = oldThr << 1; // double threshold，扩容的是数组的长度，扩容一倍，原来的*2
}
//下面的是oldCap = 0，就是数组为空时
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//将原来容量设置为数组的长度
else { // zero initial threshold signifies using defaults
//此时oldThr=0，没有指定容量，故要以默认的数据为Table初始化一个数组
newCap = DEFAULT_INITIAL_CAPACITY;//数组长度=16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//所能容纳的映射关系的对数0.75*16
}
if (newThr == 0) {
//如果有了数组的长度，但是没有指定容量极限，在这里赋值
float ft = (float)newCap * loadFactor;//长度*负载因子
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;//此时，newThr已经被赋值了，
@SuppressWarnings({"rawtypes","unchecked"})
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 = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
//链表中的最后一个节点
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果e.next ！= null 并且 e是TreeNode的类，是红黑树结构
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//如果e.next ！= null 并且 e不是是TreeNode的类不是红黑树结构
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) {
//是e元素的位置是第一个桶
/*
*/
if (loTail == null)
//如果尾部为空，则是首次进入，首部=e
loHead = e;
else
//尾部不等于null，证明不是第一次进入，loTail.next=e
loTail.next = e;
loTail = 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
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
//数组位置改变时
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
} 其实扩容操作，就是先判断是否需要扩容，实际上是创建一个新的数组，让后在将扩容之前的数组的数据复制到新的数组中。
——HasHMap的删除操作
/*
根据指定的key，删除节点并返回删除的节点的值
*/
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/*
该方法重载，remove(Object key),根据指定key删除
remove(Object key, Object value)，根据指定的key和value删除
*/
@Override
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
删除节点时，如果节点为null，返回null，不为null，返回删除节点的值，这个方法调用了removeNode()方法，我们来看一下这个方法。
/*
删除节点
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//false, true
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
//第一步肯定要判断数组是否为空，定位的桶中的是否为空
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//第二步，就是判断第一个节点，是否相等
node = p;
else if ((e = p.next) != null) {
//第三步就是判断是否有下一个节点
if (p instanceof TreeNode)
//第四部就是判断是否为树结构
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//第五步循环遍历
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;//这里的p其实一直是当前节点的上个节点，
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//这里的node节点，就是要根据key，得到的要删除的节点
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
//这里要输出的节点，是首节点
tab[index] = node.next;
else
//删除的节点不是首节点，此时的P节点是上一个节点，
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
——HasHMap的获取操作
/*
根据指定的key，获得value
*/
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;其实就是调用了getNode()方法，我们前面已经分析过了
}
——HasHMap的替换操作
/*
替换，根据指定的key和value，替换value值，替换成，返回true，失败返回false
*/
@Override
public boolean replace(K key, V oldValue, V newValue) {
Node<K,V> e; V v;
if ((e = getNode(hash(key), key)) != null &&
((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
/*
在if()语句中，就会获得key值得节点
*/
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
/*
根据指定的key，替换value
*/
@Override
public V replace(K key, V value) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}
——HasHMap的其他操作
//获得长度，其实是将Map集合的key-value对映射到Set集合中，根据set集合获得长度
public int size() {
return size;
}
//判断HASPMap是否为null
public boolean isEmpty() {
return size == 0;
}
/*
获得节点，判断所有的key值，有相等的，就包含
*/
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
/*
清除，将数组的每个元素都设置为null
*/
public void clear() {
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
/*
是否包含根据指定的value值，就是遍历，比较每个节点的value值
*/
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
/*
方法感觉没啥用，就是传入一个key值和一个默认的value值，根据key值查找这个节点，如果没有找到该节点，
返回默认的value值(也就是我们传入的值)
如果找到了该节点，就返回该节点的value值
*/
@Override
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
——HasHMap的映射操作(values(),keyset())
/*
将所有的key，添加到一个set集合中，keySet()在AbstractMap类中已经实现了
*/
public Set<K> keySet() {
Set<K> ks;
return (ks = keySet) == null ? (keySet = new KeySet()) : ks;
}
/*
将所有的value添加到一个collection集合中
*/
public Collection<V> values() {
Collection<V> vs;
return (vs = values) == null ? (values = new Values()) : vs;
}
其实，用到了两个内部类，Values和KeySet，Values继承了AbstractCollection，KeySet继承了AbstractMap，并实现了相应的方法。values和keyset变量在父类的集合中就有了定义，在父类中就根据迭代器的迭代将key和value根据相应的操作放在Collection集合和Set集合中了。我认为在HashMap类中之所以有KeySet内部类和Values内部类，是因为要判断keyset和values是否为null，如果为null，要返回相应的类型，所以分别继承了AbstractCollection和AbstractMap。
Map集合中在jdk1.8版本中，增添了很多东西，如以前的HashMap集合只是由散列表组成，但是现在一个桶的最大容量只是8个节点，超过这个容量，就会转变为红黑树结构。这里就先不提这些东西了，我是真心不想看那些代码了，而且，我的水平是真的有限。嗯，原谅我！！！