一、HashMap的原理
所谓Map，就是关联数组，存的是键值对——key&value。
实现一个简单的Map，你也许会直接用两个LIst，一个存key，一个存value。然后做查询或者get的时候，就遍历key的list，然后返回相应的value。
这样时间复杂度显然就是线性的，但这在map中已经是效率最低的get的方法了。而Hash主要提高效率的，也就是在这个位置——key的定位和查询这。
在数据结构中，我们学了hash这一技术，也就是散列表的技术。我们把整个表格看作是许多许多的空桶，然后散列函数也就是hash函数（拿质数来取模是一个很经典的hash的方法）会把你传入的参数处理后，散列到这些桶中。一个完美的哈希函数呢，是可以将你的输入无冲突的散列到表格中，也就是你传入的参数一人进一个桶，互相之间不冲突。但这是不可能的，然后数据结构中学到了很多处理冲突的方法，有链表处理法——就是在桶中冲突的元素用链表将他们存起来；还有线性探测法等，这些大概就是碰到冲突，然后根据一些算法来换位置，再冲突就再换。
Java的HashMap就是用散列表这一技术来存key和value。在HashMap中，我们hash函数的对象是Key instance，用一个Node[][]的二维数组来做table。这个Node是结点，一个Node代表着一个key和一个value，可以理解成HashMap中存储的一个对象。这个table可以看作是桶群，每个node都是一个桶。
当然传进hash函数的不可能直接是这个Key的实例对象，而是它的hashCode()方法产生的一个hash code。这个hashCode()方法是基类Object的一个方法，如果你不对这个方法进行重写的话，hashCode()方法返回的是根据这个对象的地址生成的一个int的散列码。
jdk对这个key instance的hashcode进行一个处理后，然后将它散列出一个值，作为桶的index，然后将这个key代表的node放进桶里面。对hashCode的处理会在下面的源码分析中介绍到。
jdk1.8后的hashMap还对数据结构做了一个处理，当一个桶冲突的链表太长了的时候，会把链表改成红黑树，然后当冲突小了的话，又会变回链表。
补充：看了源码后发现，只是对那个桶的链表进行转换。
tips：如果你的类直接当作key在hashMap中使用的话，equals和hashCode这两个方法用的都是Object默认的，也就是说主要比较的是对象的地址。如果你想根据你的类的实例的内容来进行散列的话，请重写hashCode；如果你想通过你的类的实例的内容来进行key的查找的话，请重写equals方法。
而且你重写的hashCode不一定要是unique的，但你重写的equals方法一定要严格区分不同的对象！！
可以参考String这个例子，这个类就可以很好地在hashMap中当key使用，它重写了hashCode()和equals()，都是根据String的内容来生成的。
二、源码重要部分解析
类的声明部分：
继承了AbstractMap，这是个Map接口的简单实现类。然后实现了Map、Cloneable接口（之前的博客有讲过，这里是为了实现浅复制）还有序列化的Serializable接口。
常量部分：
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
首先这个capacity指的是HashMap中的桶表格——table （下面会说到）所分配的内存。所以这个常量的意思是table的初始length也就是初始化的长度，为16。
static final int MAXIMUM_CAPACITY = 1 << 30;
table的capacity的最大值，如果用户在构造器中间接指明的的参数大于等于这个最大值的时候，table的capacity就会取这个。这个值是2的30次方。
这里我们会看到，而且源码中的备注中也有写到，这里的capacity一定要是2的整数次幂，因为这样才能很方便地用&、^等位操作符来进行一些运算，速度更快，下面的hash算法还有很多算法中会看到。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
这个参数是加载因子，load_facotr = size/capacity，也就是map中存储的entry（键值对实体）除以table数组容量的值。这个值很重要，当这个facotr到达了这个数值，map就会进行扩容操作。如果在Map的构造器中没有特别指定load_factor，用的就是0.75.
static final int TREEIFY_THRESHOLD = 8;
这个值是说，table中，如果有桶（bucket）的链表的长度大于8，就有可能把所有的链表变成红黑树，是转变成树的一个阈值。
static final int UNTREEIFY_THRESHOLD = 6;
这个值是退化回链表的一个阈值，在扩容操作的时候，如果桶中的node数目小于6就变回链表喔。
static final int MIN_TREEIFY_CAPACITY = 64;
这个值是在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。
嵌套类Node的声明
/**
* Basic hash bin node, used for most entries. (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
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) {
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);//大概是想让node的hash值和key和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;
}
}
这个Node的声明在LinkedHashMap还有TreeNode中都会用到，是他们的爸爸和爷爷。
这个类就是一一个链表结点，是每个桶的最常规的结点类。
类变量有一个final的hash，代表的是这个Node的key instance的处理过的hash值。（就是这个Key instance的hashCode()值经过处理后的一个值，代表这个Key instance）；finall Key还有V value；Node next是指向下一个Node的指针，只有一个Next指针，可见这是个单向链表。
重写了hashCode()方法——key的hashCode()和value的hashCode()相亦或；重写了equals()方法——需要对key和value都进行比较。
hash方法——扰乱函数
static final int hash(Object key) {
//扰乱函数 h无符号右移16后，相当于处以高位的16位被移到了低半段的16位，这个时候高半段都是0
//然后再和本来的h做亦或，其实就是h的高半段和低半段做亦或（因为移位后的h前面都是0嘛），
//这样就混合原始哈希码的高位和低位，以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
在本文的HashMap的原理介绍中有提到，我们会对Key instance的hashCode()进行一个处理后再序列化到table的桶中，这个函数就可以看作是那个处理的算法。具体的分析都写在注解中了。
得到的是一个随机性很高的只有低半位的整形，后面序列的时候我们会用一个方法只取这个整形的低位部分。
一个很好玩的方法——tableSizeFor()
/**
* Returns a power of two size for the given target capacity.
*/
//给一个整数，返回大于输入参数且最接近的2整数次幂数
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
//累计移了31位，这段代码其实就是把最高位的1后面的全部变成1
//0100变成0111，4变成7 全是1加个1就变成了2的整数幂了，7+1=8返回
//所以第一步要先把参数减1，假如传进来是4，不减一的话就直接得到8返回显然错了
//减一再处理就是3=0011，处理完就是返回0011+0001=0010=4正确
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
这个方法的作用和解析都写在注解中了。以前没怎么用过移位运算符的我觉得好厉害哈哈哈。
类变量声明部分
transient Node<K,V>[] table;//HashMap中的那个桶数组，键值对就是散列在这个Node，这个table分配的容量是capacity。
transient Set<Map.Entry<K,V>> entrySet;
这个类变量就是一个装了HashMap的所有键值对实体的一个Set。
/** * The number of key-value mappings contained in this map. */ transient int size;
注释说的很清楚了，map中键值对的数量。
transient int modCount;
//这个field是用来标识HashMap的结构被修改的的次数，比如键值对的添加或者是内部结构的改变，像覆盖update这些操作不算。
//这个是用来给 iterators做fail-fast机制用的，就是iterator的时候如果HashMap还被别的进程改变会抛出异常的机制。
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
int threshold;
//准备扩容的阈值吧 说如果table array没有分配，这个值是原始array的capacity喔
这个值是capacity*load_factor得到的值，也就是说，当HashMap中的键值对的数量超过这个的时候，就要考虑扩容了。
这个值其实困扰了我蛮久的，注解上说什么如果table还没allocated，就设置为默认的array capacity……这里还真有点不懂，是指initial capacity对应的threshold吗？
这个threshold其实应该理解成，这个HashMap应该容纳的node的个数，因为一超过这个值就要扩容嘛，相当于这个HashMap的“capacity”。而且我们注意，HashMap的类变量中没有capacity这个变量！！所以其实构造器还有初始化只是和这个threshold在打交道。
构造方法系列
HashMap中有四个构造方法：
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
*
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
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;
this.threshold = tableSizeFor(initialCapacity);//一开始
}
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* Constructs a new <tt>HashMap</tt> with the same mappings as the
* specified <tt>Map</tt>. The <tt>HashMap</tt> is created with
* default load factor (0.75) and an initial capacity sufficient to
* hold the mappings in the specified <tt>Map</tt>.
*
* @param m the map whose mappings are to be placed in this map
* @throws NullPointerException if the specified map is null
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
第一个是最典型的，用户声明hashMap容量还有load_factor。注意，这个initialCapacity其实应该指的是HashMap的容量，因为它是经过tableSizeFor()处理后再赋值给threshold。
第二个只是指定了initialCapacity，直接调用了第一个构造器方法。
第三个是什么都没指定，构造器里只是对threshold进行了默认赋值，素以这个构造器调用的话，获得的HashMap的instance的threshold应该为0.
第四个传进来的是个Map，然后调用putMapEntries()方法。
补充：
（下划线部分有误）
后面发现这个initialCapacity还是设的是table的capacity，因为在resize()方法中，要给新的table分配内存的时候，用的就是这个initialCapacity，只不过用的是这个threshold来传值。所以第一点说的initialCapacity是不对的，它指的还是HashTable中的table的容量。
但threshold是这个hashMap的容量是没错的，因为确实超过这个值就要扩容或者进行操作。
putMapEntries()方法
如果是构造器调用的初始化的话，这个evict参数就为false，否则的话就是true（putAll方法就是true）
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();//传进来的map的键值对的个数
if (s > 0) {
if (table == null) { // pre-size
//说明这个table还没分配内存初始化
float ft = ((float)s / loadFactor) + 1.0F;
//ft是，如果根据传进来的map的node的数量，创建table分配table，应该table的capacity是多少
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
//给threshold赋值
threshold = tableSizeFor(t);
}
else if (s > threshold)
//说明m的个数比所在map最多可以存储的node数量要多，所以要扩容或者是为table分配内存。
resize();//这个方法可以扩容和为table分配初始的内存。
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
//利用entrySet获取这个Map中所有node的一个Set
//然后调用putVal()方法来为本HashMap添加node，或者说添加键值对。
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
这个方法是putAll()方法还有构造器传map进来的话，这两个方法的内部相关实现。
这个float ft = ((float)s / loadFactor) + 1.0F;这一行代码中为什么要加1.0F我不太懂，网上有说是可以节省一次resize()，也有说精确小数点后几位……emm不知道。
关于这个putVal()方法，在下面会介绍到。
get方法和getNode
public V get(Object key) {
//直接调用getNode()然后返回node的key
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key 这个key instance的经过hash()过的hash值
* @param key the key
* @return the node, or null if none
*/
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) {
//进来后tab是当前table，n是table的capacity，first是这个key对应的那个位置的桶的第一个node
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
//看这个桶的第一个node的key是不是这个要get的key
//因为有些对象的引用不一样，但equals是一样的，像是文字一样的String对象
//看了后面的代码发现，很多涉及查找的都是这样先桶的第一个node进行比较。
return first;
if ((e = first.next) != null) {
//第一个node不是要get的那个key，而且有下一个元素，也就是可能是链表也可能是树
if (first instanceof TreeNode)//如果是树，则交给树的getTreeNode的实现来完成
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;
}
具体看里面的注解就行了。
put方法
public V put(K key, V value) {
//调用putVal方法
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don‘t change existing value这个值如果为true，就不改变原来的值，就如果put是覆盖原来的key的值，这个又为true的话就不能改变喔，虽然不知道哪里用hh
* @param evict if false, the table is in creation mode.这个值如果为false的话，这个table就处于一个创造的模式，就是那个传map的构造器在初始化当前map，然后间接调用的这个方法。
* @return previous value, or null if none
*/
//put方法里面调用的后面的两个参数分别是false和true，说明可以覆盖原来的key的value；不是一个creation mode
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)
//进来这里的话说明这个table还没分配空间呢，tab是table，然后n是table的capacity
n = (tab = resize()).length;//这一步相当于调用resize()方法为table分配内存并返回一个node数组作为table，然后将这个新的table的capacity给n
if ((p = tab[i = (n - 1) & hash]) == null)
//p是这个要put的key的对应的table中的那个桶的第一个node，i是这个key对应的那个桶的index
//如果这个桶为空，说明还没冲突，就新建一个普通的结点。
tab[i] = newNode(hash, key, value, null);
else {
//否则就是有冲突了，可能这个桶下是链表也可能是树
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//先判断桶中的第一个node的key是不是这个要put的key，是的话将这个node赋值给e
e = p;
else if (p instanceof TreeNode)
//如果第一个不是那个key，先看这个node是不是树，是的话交给树的操作。
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//说明这个桶下面接的是链表，而且第一个不是正确的要put的key，那就遍历链表找咯
for (int binCount = 0; ; ++binCount) {//遍历的时候要数着node的数量，因为可能添加的时候load_factor要超过，要变成树。
if ((e = p.next) == null) {//e往下遍历
//这句之后，e就是下一个结点，如果进入这个条件里面，说明链表已经到头了
//而且还没找到那个key，所以就插入新结点了
//插入后break，这时候e指向null
p.next = newNode(hash, key, value, null);//这一步就是插入的那个语句
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//添加了新结点嘛，然后就要看这个桶的链表的node数量过多没，过多可能就要进行树化操作。
//在treeifyBin方法中还有个判断map中键值对总数超过64没的操作，超过了才树化。
treeifyBin(tab, hash);//这个方法的操作是，把这个桶的单向链表变成树
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//如果遍历中发现有相同的key，就跳出来
//这个时候e指的是key和要put的那个key相等的node
break;
p = e;
}
}
if (e != null) { // existing mapping for key
//e不为null的话，说明上面的操作找到了 一个key和要put的可以一样的node
//这个e指的就是那个key和put那个key一样的node
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)//条件允许，覆盖
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//到了这里说明这个key还不存在，那么就要insert一个node，hashMap结构要改变所以这个值加一
if (++size > threshold)
//插入后size大于阈值，
resize();
afterNodeInsertion(evict);
return null;
}
关于这个treeifyBin()方法，下面也简单介绍下：
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();//这个情况下，还不至于进行结构的转换，只要扩容就好。
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
//树首结点还有树尾结点
//其实就一个头节点，然后一个用来遍历的尾结点
do {
TreeNode<K,V> p = replacementTreeNode(e, null);//把这个结点转换为树结点
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//这一步做的，其实就是1.把所有的node结点变成TreeNode
//2.把单向链表变成双向链表
if ((tab[index] = hd) != null)
//这一步就把桶的首元素变成这个双向链表的头结点
hd.treeify(tab);//把这个双向链表变成树
}
}
一开始我以为，一旦发现需要变树，是把所有桶的链表都变成树，看到这里才发现只是变这个桶的链表。
可以看到，这里的treeifyBin()方法其实还不是把链表变成树，只是把结点都变成了TreeNode，然后还把单向链表变成了双向，然后最后调用
树头指针.treeify(tab)
这个语句才是把这个双向链表树化，应该是这样转换后，可以更方便地写转换成红黑树的代码吧。
关于红黑树的构造就不在这里细讲了。
然后是我们很重要的resize()方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//获取当前的桶表格table
int oldCap = (oldTab == null) ? 0 : oldTab.length;//获取当前的table的capacity
int oldThr = threshold;//获取当前的阈值，就是现在这个HashMap能够装几个node
int newCap, newThr = 0;
if (oldCap > 0) {
//进入这里说明table已经有了，准备进行扩容
//补充一下，如果当前有table，但table的capacity经过double后大于maxCap的话，下面两个if都不进入
//这种情况经过下面两个if后，newCap的值为大于maxCap的double * oldCap；newThr为0
//这个情况我们叫做%%，等等好描述
if (oldCap >= MAXIMUM_CAPACITY) {
//当前table的capacity大于maxCapability
//就把阈值赋值为Integer的max
//然后什么都不做返回当前table
//一开始很奇怪，为什么当前capacity要和max比较，应该不可能大于max啊，后面分析其实是有可能的
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//这个else应该就符合扩容的要求，准备扩容
//进入这个if的话，就newCap是当前capacity的double而且小于maxCap
//而且当前cap也正常，所以可以double
//下面就阈值double，也就是newThr的值是当前的阈值的double
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
//这里我们叫做情况#@好了，等等好描述
//这个else是说明还没有table
//这里的if说明用户在构造器中指定了initialCapacity
newCap = oldThr;
//在构造器代码中，用户将initialCapacity传给了threshold，
//所以当前threshold传给这个新的capacity，完全没毛病
//可见这个情况下，newThr的值还是0
else { // zero initial threshold signifies using defaults
//这里就说明，没有table，而且构造器中没有指定threshold，也就是调用的是无参构造器
//所以newCap和newThr都为默认值。
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//看上面的分析就知道，有两种情况newThr会为0：
//#@的情况，也就是没有table，用户指定了initialCapacity
//%%的情况，也就是有table但两倍oldCap大于MaxCap的情况
//根据用户给的initialCapacity算threshold
//或者根据大于maxCap的newCap算出它对应的threshold
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
//根据newCap给newThr赋值，newCap太大的话就给newThr赋值为整型的最大值
//这里看到，如果是%%情况，newCap是不会变的，也就是还是>maxCap，所以是存在capacity大于maxCapacity的情况的，
//但这个不怕它越界，因为即使是maxCap*2也不会大于Integer的maxValue
}
threshold = newThr;//好的，现在要更新这个阈值了
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//根据newCap来分配table的内存
table = newTab;赋值给table，真正扩容或者分配内存
if (oldTab != null) {
//这里做的，是如果是扩容操作，那么要把旧的table中的东西迁移到现在的table中
for (int j = 0; j < oldCap; ++j) {
//对旧table的桶进行遍历
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//e是不为空的那个桶的首个node
oldTab[j] = null;//将这个桶的引用置空，然后交给gc处理
if (e.next == null)
//说明这个桶没有冲突，只有一个node
//那么就直接根据散列算法取hash低位然后散列到扩容后的table中去
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//这个else就意味着，桶下面的可能是链表或者树
//这里是树的情况，就交给树的split操作来处理
//这里应该有如果数量下来了然后又变回链表的操作
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//这里是桶下面是个链表的情况，要做的是将这个桶下的链表变成两条链表，然后分别散列到新table中的两个桶中
Node<K,V> loHead = null, loTail = null;//一号新链表的头指针和用来遍历的尾指针
Node<K,V> hiHead = null, hiTail = null;//二号新链表的头指针和用来遍历的尾指针
Node<K,V> next;//用来遍历原来旧表中那个桶的链表的指针
do {
next = e.next;//next往下移
//这个e.hash & oldCap有两种情况，要么就等于oldCap，要么就等于0
//因为cap都是2的整数次幂嘛，所以都是10000的形式，也就只有最高位为1
//对旧链表中每个结点都进行这个&操作，就把node分成两类，形成两个链表
if ((e.hash & oldCap) == 0) {
//1号新链表的构造
if (loTail == null)//第一次遍历，先把头指针赋值
loHead = e;
else
loTail.next = e;
loTail = e;//可见这里用的是尾插法，jdk7好像用的是头插法，然后头插法好像在多线程环境下可能变成环然后死循环。
}
else {
//2号新链表的构造
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;//2号新链表收尾
newTab[j] = loHead;//j是旧桶在旧table中的index，新table中的这个桶第一个node变成一号新链表的头指针
}
if (hiTail != null) {
hiTail.next = null;//2号新链表收尾
newTab[j + oldCap] = hiHead;//新table中的与1号链表相隔oldCap个距离的桶第一个node变成二号新链表的头指针
}
}
}
}
}
return newTab;
}
最后讲一下这个新的两条链表的操作。
如果还是按照hash & cap - 1的操作的话，其实还是很不分散。因为你hash是不会变的嘛，然后cap在旧的基础上翻倍后，也就比之前多了一位。
也就是说hash & cap - 1就比之前那个旧的桶的index多了一位，那么原来桶中的这个index很可能仍然是旧的那个值。
而现在这个直接用旧桶的index然后另一个新链表的index为就桶index + oldCap的操作，就：
1. 让node在新table中的散列结果更分散。
2. 减少计算量。
putAll方法
/**
* Copies all of the mappings from the specified map to this map.
* These mappings will replace any mappings that this map had for
* any of the keys currently in the specified map.
*
* @param m mappings to be stored in this map
* @throws NullPointerException if the specified map is null
*/
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
调用putMapEntries()方法，然后这里不是初始化table，所以第二个参数传true。
remove方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
* Implements Map.remove and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored 如果下面那个参数为true，这个value参数就有用
* @param matchValue if true only remove if value is equal 如果这个为true，那么只有在这个key对应的value和上面那个参数value相同才删除
* @param movable if false do not move other nodes while removingfalse的话，删除的时候不移动其他node喔
* @return the node, or null if none找不到node返回null
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
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) {
//tab为table，n为capacity，p为key那个桶位的第一个node
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//判断第一个是不是那个要删除的key的node，是的话赋值给node
node = p;
else if ((e = p.next) != null) {
//如果第一个不是要删除的node
//而且还有下一个，也就是下面可能是链表或者树
if (p instanceof TreeNode)
//如果这是棵树，交给树的getTreeNode
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//否则，这里就是个链表，那就遍历找要删除的那个key呗
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
//找到，就赋值给node
//然后break出来
node = e;
break;
}
p = e;//p总是指向遍历中的那个e的爸爸，如果break出去的话，p就是要删除的那个node的爸爸
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//node不为空，说明找到了要删除的node
//而且如果matchValue，要删除的node的value和传进来那个相同
if (node instanceof TreeNode)
//如果要删除的是树结点，交给树的操作
//大概瞄了一眼，里面有如果node数量太少，变回链表的操作
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
//node不是树结点，而且要删除的node就是桶里面的首结点
//因为这个node==p只可能出现在，桶里面第一个元素就是要删除的node这种情况下
tab[index] = node.next;//那么就桶的首元素的next直接指向node的下一个咯
else
//不是树，而且要删除也不是第一个元素
//p是node的爸爸，素以直接p的next指向node的next
//剩下的就交给gc，Java就是爽哈哈哈
p.next = node.next;
++modCount;//删除了结点，hashMap的结构肯定改变了啊，那就这个值加一
--size;
afterNodeRemoval(node);//一个linkedHashMap的回调函数
return node;//返回删除的结点
}
}
return null;
}
Clear方法
就是遍历table然后把数组元素的引用都置空，gc舒服啊
/**
* Removes all of the mappings from this map.
* The map will be empty after this call returns.
*/
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;
}
}
containsKey和containsValue方法
containsKey源码：
/**
* Returns <tt>true</tt> if this map contains a mapping for the
* specified key.
*
* @param key The key whose presence in this map is to be tested
* @return <tt>true</tt> if this map contains a mapping for the specified
* key.
*/
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
containsKey方法就直接调用getNode方法，看找不找得到这个key的node
containsValue源码：
/**
* Returns <tt>true</tt> if this map maps one or more keys to the
* specified value.
*
* @param value value whose presence in this map is to be tested
* @return <tt>true</tt> if this map maps one or more keys to the
* specified 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;
}
这个可读性也很高，就是遍历table的每个桶，每个桶再单向遍历链表。当然，只有桶中有node才会去遍历链表。
但这里有个问题，如果桶里面是红黑树，这里为什么也能用单向链表e = e.next的方式去遍历？？
可能只有在迟点了解学习红黑树才能懂。
emmm我认为HashMap这些方法是比较重要的，HashMap的第一次源码学习就到这了，接下来应该学下红黑树。（数据结构课上竟然没教）
原文地址：https://www.cnblogs.com/wangshen31/p/10381322.html