/**

 * An empty table instance to share when the table is not inflated.

 */

static final Entry<?,?>[] EMPTY_TABLE = {};

/**

 * The table, resized as necessary. Length MUST Always be a power of two.

 */

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

static class Entry<K,V> implements Map.Entry<K,V> {

    final K key;

    V value;

    Entry<K,V> next;

    int hash;

    ...

}

/**

 * The table, initialized on first use, and resized as

 * necessary. When allocated, length is always a power of two.

 * (We also tolerate length zero in some operations to allow

 * bootstrapping mechanics that are currently not needed.)

 */

transient Node<K,V>[] table;

static class Node<K,V> implements Map.Entry<K,V> {

    final int hash;

    final K key;

    V value;

    Node<K,V> next;

    ...

}

/**

 * Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn

 * extends Node) so can be used as extension of either regular or

 * linked node.

 */

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {

    TreeNode<K,V> parent;  // red-black tree links

    TreeNode<K,V> left;

    TreeNode<K,V> right;

    TreeNode<K,V> prev;    // needed to unlink next upon deletion

    boolean red;

    ...

} 

    /**

     * Associates the specified value with the specified key in this map.

     * If the map previously contained a mapping for the key, the old

     * value is replaced.

     *

     * @param key key with which the specified value is to be associated

     * @param value value to be associated with the specified key

     * @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 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;

    }

/**

 * Rehashes the contents of this map into a new array with a

 * larger capacity.  This method is called automatically when the

 * number of keys in this map reaches its threshold.

 *

 * If current capacity is MAXIMUM_CAPACITY, this method does not

 * resize the map, but sets threshold to Integer.MAX_VALUE.

 * This has the effect of preventing future calls.

 *

 * @param newCapacity the new capacity, MUST be a power of two;

 *        must be greater than current capacity unless current

 *        capacity is MAXIMUM_CAPACITY (in which case value

 *        is irrelevant).

 */

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;

        }

    }

}

if (oldTab != null) {

    // 从索引 0 开始逐个遍历旧 table

    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)    // 红黑树，先不管

                ((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;

                        else    // 通过尾部去关联 next，维持了元素原有顺序

                            loTail.next = e;

                        loTail = e;

                    }

                    else {

                        // 相同偏移量的元素链表

                        if (hiTail == null)

                            hiHead = e;

                        else    // 通过尾部去关联 next，维持了元素原有顺序

                            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;

                }

            }

        }

    }

}