static class Node<K,V> implements Map.Entry<K,V> {final int hash; //哈希值final K key;//keyV value;//valueNode<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; }//每个节点的hashcode是由key的hashcode和value的hashcode进行异或得到的。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;}}

//默认的初始capacity
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大capacity
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的load factor
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//存储Node节点的数组
transient Node<K,V>[] table;

//HashMap中元素数量的阈值，当元素数量超过阈值时，就会发生扩容
int threshold;//负载因子，用于计算HashMap元素数量的阈值，threshold=table.length * loadFactor
final float loadFactor;

//初始化一个指定初始化capacity和loadfactor的HashMap
public HashMap(int initialCapacity, float loadFactor) {//边界检查，capacity不能为负数 　　　　if (initialCapacity < 0)throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);　　　　　//如果超过最大的capacity，设置为capacityif (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;if (loadFactor <= 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: " +loadFactor);this.loadFactor = loadFactor;　　　　　//threshold由initialCapacity计算得来this.threshold = tableSizeFor(initialCapacity);
}

/*** 根据期望容量cap返回2的n次方的哈希桶的实际容量，返回值一般大于等于cap*/
static final int tableSizeFor(int cap) { //假设cap=3int n = cap - 1;//n=2,二进制写法是00000010n |= n >>> 1;//先右移一位是00000001,或的结果是00000011n |= n >>> 2;n |= n >>> 4;n |= n >>> 8;n |= n >>> 16;//最终n=3,最后返回n+1return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR;
}
//初始化一个HashMap,将另一个map的元素放入这个HashMap中。
public HashMap(Map<? extends K, ? extends V> m) {this.loadFactor = DEFAULT_LOAD_FACTOR;putMapEntries(m, false);
}
//将另一个map的所有元素加入表中，参数evict初始化时为false,其他情况为true
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {//先获取map的大小int s = m.size();//如果大于0if (s > 0) {//如果table此时为nullif (table == null) { // pre-size//根据m的元素数量和负载因子计算出阈值float ft = ((float)s / loadFactor) + 1.0F;//不能超过最大capacityint t = ((ft < (float)MAXIMUM_CAPACITY) ?(int)ft : MAXIMUM_CAPACITY);//如果t大于当前的阈值，返回一个新的满足2的n次方的阈值if (t > threshold)threshold = tableSizeFor(t);}//如果此时table不为空且m的元素数量大于thresholdelse if (s > threshold)resize();//扩容，以便容纳m的所有元素，有可能出现扩容以后还是无法容纳所有元素，但因为putVal方法里面会扩容。//遍历m依次将元素放入HashMap中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);}}
}

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

final Node<K,V>[] resize() {//oldTab为当前哈希桶Node<K,V>[] oldTab = table;//oldCap为当前哈希桶的容量int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldThr为当前的阈值int oldThr = threshold;//初始化newCap和newThr为0int newCap, newThr = 0;//如果当前哈希桶容量大于0if (oldCap > 0) {//如果当前哈希桶容量大于等于最大容量，就只好随你碰撞了if (oldCap >= MAXIMUM_CAPACITY) {//阈值为int类型的最大值threshold = Integer.MAX_VALUE;//返回当前哈希桶，不再扩容return oldTab;}//newCap等于当前哈希桶容量的两倍，如果这个值小于最大容量,且当前哈希桶容量大于等于默认初始容量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 {               // 如果当前哈希桶为空，且阈值也为0newCap = DEFAULT_INITIAL_CAPACITY;//新的容量为默认初始容量//新的阈值等于默认负载因子乘以默认初始容量newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}if (newThr == 0) {//如果新的阈值时0，即当前表是空的，但是有阈值，此时newCap等于当前阈值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];//更新tabletable = newTab;if (oldTab != null) {//当当前的table数组不为空时，重新分配数组中的数据。for (int j = 0; j < oldCap; ++j) {Node<K,V> e;if ((e = oldTab[j]) != null) {//将原链表置空，以便GColdTab[j] = null;//如果当前节点没有后续节点，直接赋值if (e.next == null)newTab[e.hash & (newCap - 1)] = e;else if (e instanceof TreeNode)((TreeNode<K,V>)e).split(this, newTab, j, oldCap);else { // 如果当前节点有后续节点，则要进行重新分配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;}//移动到原位置+oldCap的节点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;}

//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<K,V>[] tab; Node<K,V> p; int n, i;//如果table数组为空，则首先扩容，n为扩容后的长度if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;//(n-1)&hash计算当前的key在数组中的位置，如果该位置上还没有结点，直接putif ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);//如果已经有结点了else {Node<K,V> e; K k;//如果结点的key值与要插入的key值相同，直接覆盖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);//否则就要遍历结点所在链表后，添加在链表的尾部，e此时为头结点else {for (int binCount = 0; ; ++binCount) {//当找到链表的尾部时即下一个节点为空，在链表的尾部添加新的结点if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);                        //当链表的长度超过8，就调用treeifyBin函数　　　　　　　　　　　　　　 //当tab的大小超过64，就将链表转化为一棵红黑树，否则调用resize进行扩容                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);break;}//如果在遍历链表的时候发现有结点的key值与要插入的key值相同，退出循环if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}//当e不为null时，此时说明链表中存在要插入的keyif (e != null) { // existing mapping for keyV oldValue = e.value;//当onlyIfAbsent为false,即在存在相同的key值时进行替换(如果为true则不替换)if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);//返回原有的值return oldValue;}}//modCount加1++modCount;if (++size > threshold) //检查是否超过阈值resize();afterNodeInsertion(evict);return null; //因为原hashMap中key不存在，所有返回null}

    public V get(Object 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* @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;//如果table数组不为空，并且对应位置的链表头结点不为空if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {//如果key与链表头结点相同，则返回链表头结点if (first.hash == hash && // always check first node((k = first.key) == key || (key != null && key.equals(k))))return first;//如果key与链表头结点不同，则遍历链表if ((e = first.next) != 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;}

 /*** Removes the mapping for the specified key from this map if present.** @param  key key whose mapping is to be removed from the map* @return the previous value associated with <tt>key</tt>, or*         <tt>null</tt> if there was no mapping for <tt>key</tt>.*         (A <tt>null</tt> return can also indicate that the map*         previously associated <tt>null</tt> with <tt>key</tt>.)*/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* @param matchValue if true only remove if value is equal* @param movable if false do not move other nodes while removing* @return the node, or null if none*/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;　　　　 //如果table数组不为空，并且对应位置链表的头结点不为空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;            //如果要删除的key与链表头结点的key相同，则说明要删除的结点就是链表头结点if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))node = p;            //遍历以找到要删除的结点，以及要删除结点的上一个结点pelse 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;//将table数组对应位置赋值给其下一个结点elsep.next = node.next;++modCount;--size;afterNodeRemoval(node);return node;}}return null;}

static class Entry<K,V> implements Map.Entry<K,V> {final K key;V value;Entry<K,V> next;int hash;/*** Creates new entry.*/Entry(int h, K k, V v, Entry<K,V> n) {value = v;next = n;key = k;hash = h;}public final K getKey() {return key;}public final V getValue() {return value;}public final V setValue(V newValue) {V oldValue = value;value = newValue;return oldValue;}public final boolean equals(Object o) {if (!(o instanceof Map.Entry))return false;Map.Entry e = (Map.Entry)o;Object k1 = getKey();Object k2 = e.getKey();if (k1 == k2 || (k1 != null && k1.equals(k2))) {Object v1 = getValue();Object v2 = e.getValue();if (v1 == v2 || (v1 != null && v1.equals(v2)))return true;}return false;}public final int hashCode() {return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());}public final String toString() {return getKey() + "=" + getValue();}/*** This method is invoked whenever the value in an entry is* overwritten by an invocation of put(k,v) for a key k that's already* in the HashMap.*/void recordAccess(HashMap<K,V> m) {}/*** This method is invoked whenever the entry is* removed from the table.*/void recordRemoval(HashMap<K,V> m) {}}

 public V put(K key, V value) {if (table == EMPTY_TABLE) {inflateTable(threshold);}if (key == null)return putForNullKey(value);int hash = hash(key);int i = indexFor(hash, table.length);for (Entry<K,V> e = table[i]; e != null; e = e.next) {Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}modCount++;addEntry(hash, key, value, i);return null;}

 /*** Returns index for hash code h.*/static int indexFor(int h, int length) {// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";return h & (length-1);}

     1010010111000100001000101
&    0000000000000000000001111
---------------------------------------0000000000000000000000101

/*** Retrieve object hash code and applies a supplemental hash function to the* result hash, which defends against poor quality hash functions.  This is* critical because HashMap uses power-of-two length hash tables, that* otherwise encounter collisions for hashCodes that do not differ* in lower bits. Note: Null keys always map to hash 0, thus index 0.*/final int hash(Object k) {int h = hashSeed;if (0 != h && k instanceof String) {return sun.misc.Hashing.stringHash32((String) k);}h ^= k.hashCode();// This function ensures that hashCodes that differ only by// constant multiples at each bit position have a bounded// number of collisions (approximately 8 at default load factor).h ^= (h >>> 20) ^ (h >>> 12);return h ^ (h >>> 7) ^ (h >>> 4);}

  /*** Adds a new entry with the specified key, value and hash code to* the specified bucket.  It is the responsibility of this* method to resize the table if appropriate.** Subclass overrides this to alter the behavior of put method.*/void addEntry(int hash, K key, V value, int bucketIndex) {if ((size >= threshold) && (null != table[bucketIndex])) {resize(2 * table.length);hash = (null != key) ? hash(key) : 0;bucketIndex = indexFor(hash, table.length);}createEntry(hash, key, value, bucketIndex);}void createEntry(int hash, K key, V value, int bucketIndex) {        //获取了桶中链表的头结点Entry<K,V> e = table[bucketIndex];table[bucketIndex] = new Entry<>(hash, key, value, e);size++;}

void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}Entry[] newTable = new Entry[newCapacity];transfer(newTable, initHashSeedAsNeeded(newCapacity));table = newTable;threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);}/*** Transfers all entries from current table to newTable.*/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);e.next = newTable[i];newTable[i] = e;e = next;}}}

public V get(Object key) {if (key == null)return getForNullKey();Entry<K,V> entry = getEntry(key);return null == entry ? null : entry.getValue();}/*** Returns the entry associated with the specified key in the* HashMap.  Returns null if the HashMap contains no mapping* for the key.*/final Entry<K,V> getEntry(Object key) {if (size == 0) {return null;}int hash = (key == null) ? 0 : hash(key);for (Entry<K,V> e = table[indexFor(hash, table.length)];e != null;e = e.next) {Object k;if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))return e;}return null;}

void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}Entry[] newTable = new Entry[newCapacity];transfer(newTable, initHashSeedAsNeeded(newCapacity));table = newTable;threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);}/*** Transfers all entries from current table to newTable.*/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);e.next = newTable[i];newTable[i] = e;e = next;}}}