/**
*继承AbstractMap，并重写Map接口
**/
public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializablestatic final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 位运算，1左移4位=16static final int MAXIMUM_CAPACITY = 1 << 30;//位运算，左移30位=1073741824static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子0.75transient Entry<K,V>[] table;//entry数组 entry又是个单链表结构transient int size;//hashmap长度int threshold;//capacity * load factor 阈值比如16*0.75 = 12void resize(int newCapacity)；//扩容方法static int indexFor(int h, int length) {return h & (length-1);//计算index方法
}void createEntry(int hash, K key, V value, int bucketIndex) {Entry<K,V> e = table[bucketIndex];table[bucketIndex] = new Entry<>(hash, key, value, e);//头插法解决hash冲突size++;
}

void resize(int newCapacity) {//扩容方法：resize(2 * table.length)，当容量不足时（容量 > 阈值），则扩容（扩到2倍）Entry[] oldTable = table;//复制旧的哈希表int oldCapacity = oldTable.length;//旧的容量if (oldCapacity == MAXIMUM_CAPACITY) //容量如果等于最大值，则不再扩容threshold = Integer.MAX_VALUE;return;}Entry[] newTable = new Entry[newCapacity];boolean oldAltHashing = useAltHashing;useAltHashing |= sun.misc.VM.isBooted() &&(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);boolean rehash = oldAltHashing ^ useAltHashing;transfer(newTable, rehash);//转移数据到新哈希表里table = newTable;//完成扩容threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//重新设置阈值
}void transfer(Entry[] newTable, boolean rehash) {//将旧哈希表的数据移到新的哈希表里
//过程：按旧链表的正序遍历链表、在新链表的头部依次插入int newCapacity = newTable.length;for (Entry<K,V> e : table) {//遍历哈希表while(null != e) {Entry<K,V> next = e.next;if (rehash) {e.hash = null == e.key ? 0 : hash(e.key);}int i = indexFor(e.hash, newCapacity);//重新计算index值e.next = newTable[i];newTable[i] = e;//头部插入e = next;}}
}

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializablestatic final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//Bins are converted to trees when adding an element to a bin with at least this many nodes.
static final int TREEIFY_THRESHOLD = 8;//当桶的节点数量大于该阈值时转换为红黑树
static final int UNTREEIFY_THRESHOLD = 6;//当桶的节点数小于该阈值时会转换成链表，前提是当前是红黑树结构
static final int MIN_TREEIFY_CAPACITY = 64;//桶的节点数大于该容量时也会转换成红黑树
static class Node<K,V> implements Map.Entry<K,V> ;//换成节点了
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V>;//树节点
transient Node<K,V>[] table;//数组加单链表，后期会转红黑树
transient Set<Map.Entry<K,V>> entrySet;//数据的另一种存储方式，主要用于迭代功能
transient int size;//hashmap元素数量
transient int modCount;//该map的修改次数

static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

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;//获取长度并进行扩容，使用的是懒加载，table一开始是没有加载的，等put后才开始加载if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;if ((p = tab[i = (n - 1) & hash]) == null)//(length-1)&hash计算出索引值，判断当前哈希桶是否为空tab[i] = newNode(hash, key, value, null);//空就赋值给当前桶else {//该哈希桶不为空，会发生hash冲突，以下为发生hash冲突几种情况Node<K,V> e; K k;//第一种情况，当前的hash值相同，且key值也相同，e = p表示首节点。if (p.hash == 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) // -1 for 1sttreeifyBin(tab, hash);//节点数大于等于7，则转换红黑树结构（从0开始到7）break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;//插入节点与next节点重复，跳出循环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;
}

final Node<K,V>[] resize() {//扩容方法Node<K,V>[] oldTab = table;//之前旧的哈希表int oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;//old的表的阈值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; // double threshold 阈值也要扩大两倍}else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;//初始化的阈值else {               //容量为0，阈值就为容量*负载因子newCap = DEFAULT_INITIAL_CAPACITY;//默认初始容量16newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阈值16*0.75=12}if (newThr == 0) {//如果初始化容量小于16时，没有阈值。因为构造函数可以自己设初始容量float ft = (float)newCap * loadFactor;newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);}threshold = 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) {//当前哈希桶节点为eoldTab[j] = null;if (e.next == null)//没有下个节点newTab[e.hash & (newCap - 1)] = e;//重新计算index，放入新的哈希表中else if (e instanceof TreeNode)//有next节点，且为树节点，将此树转移到新的cap中((TreeNode<K,V>)e).split(this, newTab, j, oldCap);else { // preserve order 链表情况，将链表插入到新的哈希表节点中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;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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;//返回新的哈希表
}

public V remove(Object key) {Node<K,V> e;//判断删除的节点是否为空，不为空就返回该节点值return (e = removeNode(hash(key), key, null, false, true)) == null ?null : e.value;
}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) {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;} while ((e = e.next) != null);}}//遍历找到节点if (node != null && (!matchValue || (v = node.value) == value ||(value != null && value.equals(v)))) {if (node instanceof TreeNode)//如果删除的是红黑树节点((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);else if (node == p)//普通节点tab[index] = node.next;else//链表节点，修改next值p.next = node.next;++modCount;//修改次数加一--size;//元素减一afterNodeRemoval(node);return node;}}return null;//表示没有该节点，没找到
}