我做开发那些年

/**
 * Spreads (XORs) higher bits of hash to lower and also forces top
 * bit to 0. Because the table uses power-of-two masking, sets of
 * hashes that vary only in bits above the current mask will
 * always collide. (Among known examples are sets of Float keys
 * holding consecutive whole numbers in small tables.)  So we
 * apply a transform that spreads the impact of higher bits
 * downward. There is a tradeoff between speed, utility, and
 * quality of bit-spreading. Because many common sets of hashes
 * are already reasonably distributed (so don't benefit from
 * spreading), and because we use trees to handle large sets of
 * collisions in bins, we just XOR some shifted bits in the
 * cheapest possible way to reduce systematic lossage, as well as
 * to incorporate impact of the highest bits that would otherwise
 * never be used in index calculations because of table bounds.
 *
 * 将哈希值的高位通过异或运算（XOR）传播到低位，并强制最高位为0。
 * 由于哈希表的容量总是2的幂次方，只有低位参与桶索引的计算，
 * 如果哈希值只在高位不同，则会发生碰撞。通过这种方式将高位信息混合到低位，
 * 可以减少碰撞，提高哈希分布的均匀性。
 * 这种做法在速度、实用性和位扩散质量之间做了权衡。
 * 由于很多哈希集合本身分布较好，且对于大量碰撞会用红黑树处理，
 * 所以这里只做了简单的异或操作，既能降低碰撞，也能让高位信息参与索引计算。
 */
static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh; K fk; V fv;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else if (onlyIfAbsent // check first node without acquiring lock
                 && fh == hash
                 && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                 && (fv = f.val) != null)
            return fv;
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

/* ---------------- Fields -------------- */

/**
 * 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.)
 *
 * 哈希表，首次使用时初始化，并在必要时扩容。分配时长度总是2的幂。
 * （某些操作允许长度为0，以支持目前不需要的引导机制。）
 */
transient Node<K,V>[] table;

/**
 * Holds cached entrySet(). Note that AbstractMap fields are used
 * for keySet() and values().
 *
 * 缓存entrySet()，注意AbstractMap的字段用于keySet()和values()。
 */
transient Set<Map.Entry<K,V>> entrySet;

/**
 * The number of key-value mappings contained in this map.
 *
 * 当前Map中键值对的数量。
 */
transient int size;

/**
 * The number of times this HashMap has been structurally modified
 * Structural modifications are those that change the number of mappings in
 * the HashMap or otherwise modify its internal structure (e.g.,
 * rehash).  This field is used to make iterators on Collection-views of
 * the HashMap fail-fast.  (See ConcurrentModificationException).
 *
 * HashMap结构性修改的次数。结构性修改指改变映射数量或内部结构（如rehash）。
 * 该字段用于让Collection视图的迭代器快速失败（fail-fast）。
 * （参见ConcurrentModificationException）
 */
transient int modCount;

/**
 * The next size value at which to resize (capacity * load factor).
 *
 * 每次需要扩容的阈值（容量*负载因子）。
 *
 * @serial
 */
// (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.)
// （Javadoc描述在序列化时有效。如果table数组未分配，该字段保存初始容量，0表示DEFAULT_INITIAL_CAPACITY。）
int threshold;

/**
 * The load factor for the hash table.
 *
 * 哈希表的负载因子。
 *
 * @serial
 */
final float loadFactor;

/**
 * Constructs an empty {@code HashMap} with the default initial capacity
 * (16) and the default load factor (0.75).
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 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 {@code key}, or
 *         {@code null} if there was no mapping for {@code key}.
 *         (A {@code null} return can also indicate that the map
 *         previously associated {@code null} with {@code key}.)
 *         返回与key关联的前一个值，如果没有映射则返回null。
 *         （返回null也可能表示该映射之前将null与key关联。）
 */
public V put(K key, V value) {
    // 调用putVal方法，插入或更新键值对
    return putVal(hash(key), key, value, false, true);
}

/**
 * Computes key.hashCode() and spreads (XORs) higher bits of hash
 * to lower.  Because the table uses power-of-two masking, sets of
 * hashes that vary only in bits above the current mask will
 * always collide. (Among known examples are sets of Float keys
 * holding consecutive whole numbers in small tables.)  So we
 * apply a transform that spreads the impact of higher bits
 * downward. There is a tradeoff between speed, utility, and
 * quality of bit-spreading. Because many common sets of hashes
 * are already reasonably distributed (so don't benefit from
 * spreading), and because we use trees to handle large sets of
 * collisions in bins, we just XOR some shifted bits in the
 * cheapest possible way to reduce systematic lossage, as well as
 * to incorporate impact of the highest bits that would otherwise
 * never be used in index calculations because of table bounds.
 *
 * 计算key的hashCode，并将高位的hash通过异或运算混合到低位。
 * 因为哈希表的长度总是2的幂，只有低位参与寻址，如果高位不同而低位相同会导致哈希冲突。
 * 通过将高位与低位异或，可以让高位的信息参与寻址，减少哈希冲突。
 */
static final int hash(Object key) {
    int h;
    // 如果key为null，返回0，否则返回hashCode与其高16位右移后异或的结果
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

int index = (table.length - 1) & hash;

/**
 * Implements Map.put and related methods.
 * 实现了Map.put及相关方法。
 *
 * @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，不覆盖已有值
 * @param evict if false, the table is in creation mode.
 *              如果为false，表示表处于创建模式
 * @return previous value, or null if none
 *         返回旧值，如果没有则返回null
 */
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为空或长度为0，则进行初始化或扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 计算哈希表下标，如果该位置为空，直接插入新节点
    if ((p = tab[i = (n - 1) & hash]) == null)
        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))))
            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 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold.
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 *
 * 初始化或扩容哈希表（容量加倍）。如果table为null，则根据threshold字段分配初始容量。
 * 否则，由于采用2的幂次扩容，原哈希表中的元素要么保持原索引，要么以2的幂为偏移移动到新表中。
 *
 * @return the table
 *         返回哈希表数组
 */
final Node<K,V>[] resize() {
    // 记录原来的哈希表、哈希表容量与阈值
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    // 初始化新的容量与阈值
    int newCap, newThr = 0;
    // 从这里开始就是关于容量的核心计算方式
    // 情况一：容量大于0，哈希表数组已经初始化，进行正常扩容
    if (oldCap > 0) {
        // 情况一：容量大于0，哈希表数组已经初始化，进行正常扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 如果已达最大容量2^30，阈值设为最大，直接返回，不进行容量调整
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 情况二：容量在默认值16和最大值2^30之间，正常扩容，让容量翻倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold 
    }
    else if (oldThr > 0)   // 情况二：数组未初始化，但构造时指定了初始容量，这种情况下，初始容量值被保存在 threshold 变量里
        newCap = oldThr;  // initial capacity was placed in threshold
    else {               // 情况三：数组未初始化，且构造时未指定容量（调用 new HashMap()）
        newCap = DEFAULT_INITIAL_CAPACITY; // 默认初始容量
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 默认阈值
    }
    // 处理情况二中的 newThr 未被赋值的问题
    if (newThr == 0) {
        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) {
                // 置空旧哈希表的该桶，帮助GC
                oldTab[j] = null;
                if (e.next == null)
                    // 情况A: 桶中只有一个节点,直接迁移
                    newTab[e.hash & (newCap - 1)] = e; 
                else if (e instanceof TreeNode)
                    // 情况B: 桶中是红黑树节点，调用红黑树的split方法进行迁移
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); 
                else { 
                // 情况 C: 桶中是链表（最核心的优化点）
                // 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
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                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;
                    }
                }
            }
        }
    }
    return newTab;
}

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)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        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))))
    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 1st
                treeifyBin(tab, hash);
            break;
        }
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            break;
        p = e;
    }
}
if (e != null) { // existing mapping for key
    V oldValue = e.value;
    if (!onlyIfAbsent || oldValue == null)
        e.value = value;
    afterNodeAccess(e);
    return oldValue;
}

++modCount;
if (++size > threshold)
    resize();
afterNodeInsertion(evict);
return null;

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

final void treeify(Node<K,V>[] tab) {
    TreeNode<K,V> root = null;
    for (TreeNode<K,V> x = this, next; x != null; x = next) {
        next = (TreeNode<K,V>)x.next;
        x.left = x.right = null;
        if (root == null) {
            x.parent = null;
            x.red = false;
            root = x;
        }
        else {
            K k = x.key;
            int h = x.hash;
            Class<?> kc = null;
            for (TreeNode<K,V> p = root;;) {
                int dir, ph;
                K pk = p.key;
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0)
                    dir = tieBreakOrder(k, pk);

                TreeNode<K,V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    x.parent = xp;
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    root = balanceInsertion(root, x);
                    break;
                }
            }
        }
    }
    moveRootToFront(tab, root);
}

/**
 * Returns the value to which the specified key is mapped,
 * or {@code null} if this map contains no mapping for the key.
 *
 * <p>More formally, if this map contains a mapping from a key
 * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
 * key.equals(k))}, then this method returns {@code v}; otherwise
 * it returns {@code null}.  (There can be at most one such mapping.)
 *
 * <p>A return value of {@code null} does not <i>necessarily</i>
 * indicate that the map contains no mapping for the key; it's also
 * possible that the map explicitly maps the key to {@code null}.
 * The {@link #containsKey containsKey} operation may be used to
 * distinguish these two cases.
 *
 * @see #put(Object, Object)
 *
 * 返回指定key对应的value，如果没有该key的映射则返回null。
 * 注意，返回null不一定表示没有该key的映射，也可能是该key被显式映射为null。
 * 可以通过containsKey方法区分这两种情况。
 */
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(key)) == null ? null : e.value;
}

/**
 * Implements Map.get and related methods.
 *
 * @param key the key
 * @return the node, or null if none
 */
final Node<K,V> getNode(Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n, hash; K k;
    // 哈希表不为空且长度大于0且计算哈希表下标后获取该位置的第一个节点也不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & (hash = hash(key))]) != null) {
        // 检查第一个节点是否匹配
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 遍历链表或红黑树
        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;
}

@java.io.Serial
  private static final long serialVersionUID = 8683452581122892189L;

  /**
   * Default initial capacity.
   * 默认初始容量。
   */
  private static final int DEFAULT_CAPACITY = 10;

  /**
   * Shared empty array instance used for empty instances.
   */
  private static final Object[] EMPTY_ELEMENTDATA = {};

  /**
   * Shared empty array instance used for default sized empty instances. We
   * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
   * first element is added.
   * 用于默认容量空实例的共享空数组实例。
   * 我们将其与 EMPTY_ELEMENTDATA 区分开来，以便在添加第一个元素时知道应该扩容多少。
   */
  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

  /**
   * The array buffer into which the elements of the ArrayList are stored.
   * The capacity of the ArrayList is the length of this array buffer. Any
   * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
   * will be expanded to DEFAULT_CAPACITY when the first element is added.
   * ArrayList用于存储元素的数组缓冲区。ArrayList的容量即为该数组的长度。
   * 任何elementData为DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList，
   * 在添加第一个元素时会扩容到DEFAULT_CAPACITY。
   */
  transient Object[] elementData; // non-private to simplify nested class access

  /**
   * The size of the ArrayList (the number of elements it contains).
   * ArrayList的实际元素个数。
   *
   * @serial
   */
  private int size;

/**
 * Constructs an empty list with the specified initial capacity.
 *
 * @param  initialCapacity  the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

/**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 *
 * @param c the collection whose elements are to be placed into this list
 * @throws NullPointerException if the specified collection is null
 */
public ArrayList(Collection<? extends E> c) {
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

/**
 * Copies the specified array, truncating or padding with nulls (if necessary)
 * so the copy has the specified length.  For all indices that are
 * valid in both the original array and the copy, the two arrays will
 * contain identical values.  For any indices that are valid in the
 * copy but not the original, the copy will contain {@code null}.
 * Such indices will exist if and only if the specified length
 * is greater than that of the original array.
 * The resulting array is of the class {@code newType}.
 *
 * 复制指定的数组，如有必要会截断或用 null 填充，使复制后的数组具有指定长度。
 * 原数组和新数组中索引都有效的位置，值完全相同。
 * 新数组中多出来的部分（如果有）会用 null 填充。
 * 只有当 newLength 大于原数组长度时才会出现这种情况。
 * 返回的新数组类型为 newType。
 *
 * @param <T> the class of the objects in the returned array
 *            返回数组中对象的类型
 * @param <U> the class of the objects in the original array
 *            原数组中对象的类型
 * @param original the array to be copied
 *                 要复制的原数组
 * @param newLength the length of the copy to be returned
 *                  返回的新数组长度
 * @param newType the class of the copy to be returned
 *                返回的新数组类型
 * @return a copy of the original array, truncated or padded with nulls
 *     to obtain the specified length
 *     复制后的新数组，长度为 newLength
 * @throws NegativeArraySizeException if {@code newLength} is negative
 *         如果 newLength 为负数，抛出异常
 * @throws NullPointerException if {@code original} is null
 *         如果 original 为 null，抛出异常
 * @throws ArrayStoreException if an element copied from
 *     {@code original} is not of a runtime type that can be stored in
 *     an array of class {@code newType}
 *     如果原数组元素类型与新数组类型不兼容，抛出异常
 * @since 1.6
 */
@IntrinsicCandidate
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    // 判断目标类型是否为 Object[]，是则直接 new，否则用反射创建
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    // 复制原数组内容到新数组，长度为原数组和新数组长度的较小值
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

/**
 * Trims the capacity of this {@code ArrayList} instance to be the
 * list's current size.  An application can use this operation to minimize
 * the storage of an {@code ArrayList} instance.
 */
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

/**
 * Increases the capacity of this {@code ArrayList} instance, if
 * necessary, to ensure that it can hold at least the number of elements
 * specified by the minimum capacity argument.
 *
 * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳minCapacity指定数量的元素。
 *
 * @param minCapacity the desired minimum capacity
 *                   所需的最小容量
 */
public void ensureCapacity(int minCapacity) {
    if (minCapacity > elementData.length
        && !(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
             && minCapacity <= DEFAULT_CAPACITY)) {
        modCount++;
        grow(minCapacity);
    }
}

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * 增加容量以确保至少能容纳minCapacity指定数量的元素。
 *
 * @param minCapacity the desired minimum capacity
 *                   所需的最小容量
 * @throws OutOfMemoryError if minCapacity is less than zero
 *                          如果minCapacity小于0会抛出内存溢出错误
 */
private Object[] grow(int minCapacity) {
    // 获取老容量，也就是当前容量
    int oldCapacity = elementData.length;
    // 如果当前容量大于0 或者 元素不是默认构造器的占位符DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity, /* minimum growth 最小增长量 */
                oldCapacity >> 1           /* preferred growth 推荐增长量 */);
        // 复制原数组到新容量
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        // 如果原数组为空，则分配默认容量或minCapacity中较大的值
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}