深入理解 ArrayList 扩容机制与最大数组长度之谜

原创已于 2026-02-25 15:19:37 修改 · 273 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#开发语言 #java

于 2026-02-25 15:17:25 首次发布

ArrayList 的扩容机制

    private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        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 {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }

当向 ArrayList 中添加元素时，它会首先检查当前数组的容量是否足够。具体来说，在执行 add 方法时会判断当前的元素个数（size）是否等于数组容量（elementData.length）。若两者相等，则表示数组已满，需要触发扩容操作。

扩容操作的核心逻辑位于 grow(int minCapacity) 方法中，其参数 minCapacity代表满足当前添加操作所需的最小容量，即 size + 1。

方法的执行流程分为两种情况：

正常扩容（数组已使用过）：
如果原数组容量大于0，或者当前数组不是默认的空数组（意味着已经分配过内存），则会计算新容量。计算规则是：
- 最小增长量：minCapacity - oldCapacity（即至少需要增加多少才能满足需求）
- 首选增长量：oldCapacity >> 1（即原容量的一半，相当于扩容至原容量的1.5倍）
- ArraysSupport.newLength 方法会从这两个增长量中选取一个较大值，来确定最终的新容量。
- 确定容量后，通过 Arrays.copyOf 将原数组元素拷贝到新扩容的数组中。
首次扩容（默认空数组的第一次添加）：
如果数组是默认的空数组（即通过 new ArrayList<>() 创建且从未添加过元素），则直接创建一个新数组。其容量取 DEFAULT_CAPACITY（默认值为10）和 minCapacity 中的较大值。

简而言之，ArrayList 的扩容策略是：优先尝试按1.5倍增长，如果1.5倍不够满足最小需求，则按最小需求增长；如果是首次添加，则直接初始化为默认容量10。

最大数组长度

在阅读源码时，你会发现这么几行代码

       /**
     * A soft maximum array length imposed by array growth computations.
     * Some JVMs (such as HotSpot) have an implementation limit that will cause
     *
     *     OutOfMemoryError("Requested array size exceeds VM limit")
     *
     * to be thrown if a request is made to allocate an array of some length near
     * Integer.MAX_VALUE, even if there is sufficient heap available. The actual
     * limit might depend on some JVM implementation-specific characteristics such
     * as the object header size. The soft maximum value is chosen conservatively so
     * as to be smaller than any implementation limit that is likely to be encountered.
     */
    public static final int SOFT_MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;

    public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
        // preconditions not checked because of inlining
        // assert oldLength >= 0
        // assert minGrowth > 0

        int prefLength = oldLength + Math.max(minGrowth, prefGrowth); // might overflow
        if (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {
            return prefLength;
        } else {
            // put code cold in a separate method
            return hugeLength(oldLength, minGrowth);
        }
    }