手撕ArrayList，ArrayList底层原理是什么，它是怎么扩容的？

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

public class ArrayListCapacityDemo {

    // 自定义ArrayList类用于演示扩容过程
    static class DebuggableArrayList<E> {
        // 实际存储元素的数组
        private Object[] elementData;
        // 当前元素数量
        private int size;
        // 默认初始容量
        private static final int DEFAULT_CAPACITY = 10;
        // 共享的空数组实例
        private static final Object[] EMPTY_ELEMENTDATA = {};

        public DebuggableArrayList() {
            this.elementData = EMPTY_ELEMENTDATA;
            this.size = 0;
        }

        // 添加元素方法
        public boolean add(E e) {
            // 确保容量足够
            ensureCapacityInternal(size + 1);
            // 添加元素
            elementData[size++] = e;
            return true;
        }

        // 内部容量检查
        private void ensureCapacityInternal(int minCapacity) {
            // 计算所需容量
            int capacity = calculateCapacity(elementData, minCapacity);
            // 明确是否需要扩容
            ensureExplicitCapacity(capacity);
        }

        // 容量计算
        private static int calculateCapacity(Object[] elementData, int minCapacity) {
            // 如果是空数组，返回默认容量和所需容量的较大值
            if (elementData == EMPTY_ELEMENTDATA) {
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            }
            return minCapacity;
        }

        // 明确是否需要扩容
        private void ensureExplicitCapacity(int minCapacity) {
            // 修改计数器（用于迭代器快速失败机制）
            // modCount++;

            // 如果所需容量大于当前数组长度，则扩容
            if (minCapacity - elementData.length > 0) {
                grow(minCapacity);
            }
        }

        // 最大数组大小（一些VM在数组中保留头信息）
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

        // 扩容核心方法
        private void grow(int minCapacity) {
            int oldCapacity = elementData.length;

            // 新容量 = 旧容量 + 旧容量/2 (即1.5倍增长)
            int newCapacity = oldCapacity + (oldCapacity >> 1);

            // 如果1.5倍仍不够，则使用minCapacity
            if (newCapacity - minCapacity < 0) {
                newCapacity = minCapacity;
            }

            // 如果超过最大限制，则调整
            if (newCapacity - MAX_ARRAY_SIZE > 0) {
                newCapacity = hugeCapacity(minCapacity);
            }

            // 打印扩容信息（调试用）
            System.out.printf("扩容: %d -> %d (添加第%d个元素时触发)%n", 
                              oldCapacity, newCapacity, size + 1);

            // 实际扩容操作
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

        // 处理超大容量
        private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0) { // 溢出
                throw new OutOfMemoryError();
            }
            return (minCapacity > MAX_ARRAY_SIZE) ? 
            Integer.MAX_VALUE : MAX_ARRAY_SIZE;
        }

        // 获取当前容量（仅用于演示）
        public int capacity() {
            return elementData.length;
        }
    }
    
    public static void main(String[] args) {
        System.out.println("ArrayList扩容演示:");
        System.out.println("----------------");
        
        DebuggableArrayList<Integer> list = new DebuggableArrayList<>();
        
        // 添加30个元素，观察扩容过程
        for (int i = 0; i < 30; i++) {
            list.add(i);
            System.out.printf("添加元素: %2d, 当前大小: %2d, 当前容量: %2d%n",
                i, i + 1, list.capacity());
        }
    }
}