/**

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

        // 如果当前数组已经是默认最大容量MAXIMUM_CAPACITY ，则将临界值改为Integer.MAX_VALUE 返回

        if (oldCapacity == MAXIMUM_CAPACITY) {

            threshold = Integer.MAX_VALUE;

            return;

        }

        // 使用新的容量创建一个新的链表数组

        Entry[] newTable = new Entry[newCapacity];

        // 将当前数组中的元素都移动到新数组中

        transfer(newTable);

        // 将当前数组指向新创建的数组

        table = newTable;

        // 重新计算临界值

        threshold = (int)(newCapacity * loadFactor);

    }

    /**

     * Transfers all entries from current table to newTable.

     */

    void transfer(Entry[] newTable) {

        // 当前数组

        Entry[] src = table;

        // 新数组长度

        int newCapacity = newTable.length ;

        // 遍历当前数组的元素，重新计算每个元素所在数组位置

        for (int j = 0; j < src. length; j++) {

            // 取出数组中的链表第一个节点

            Entry<K,V> e = src[j];

            if (e != null) {

                // 将旧链表位置置空

                src[j] = null;

                // 循环链表，挨个将每个节点插入到新的数组位置中

                do {

                    // 取出链表中的当前节点的下一个节点

                    Entry<K,V> next = e. next;

                    // 重新计算该链表在数组中的索引位置

                    int i = indexFor(e. hash, newCapacity);

                    // 将下一个节点指向newTable[i]

                    e. next = newTable[i];

                    // 将当前节点放置在newTable[i]位置

                    newTable[i] = e;

                    // 下一次循环

                    e = next;

                } while (e != null);

            }

        }

}

public int size() {

    // Try a few times to get accurate count. On failure due to

   // continuous async changes in table, resort to locking.

   final Segment<K,V>[] segments = this.segments;

    int size;

    boolean overflow; // true if size overflows 32 bits

    long sum;         // sum of modCounts

    long last = 0L;   // previous sum

    int retries = -1; // first iteration isn't retry

    try {

        for (;;) {

            if (retries++ == RETRIES_BEFORE_LOCK) {

                for (int j = 0; j < segments.length; ++j)

                    ensureSegment(j).lock(); // force creation

            }

            sum = 0L;

            size = 0;

            overflow = false;

            for (int j = 0; j < segments.length; ++j) {

                Segment<K,V> seg = segmentAt(segments, j);

                if (seg != null) {

                    sum += seg.modCount;

                    int c = seg.count;

                    if (c < 0 || (size += c) < 0)

                        overflow = true;

                }

            }

            if (sum == last)

                break;

            last = sum;

        }

    } finally {

        if (retries > RETRIES_BEFORE_LOCK) {

            for (int j = 0; j < segments.length; ++j)

                segmentAt(segments, j).unlock();

        }

    }

    return overflow ? Integer.MAX_VALUE : size;

}