public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, Serializable {

    // 用于存储元素的数组
    transient Object[] elementData;

    // 默认的初始容量
    private static final int DEFAULT_CAPACITY = 10;

    // 构造方法
    public ArrayList() {
        this.elementData = new Object[DEFAULT_CAPACITY];
    }

    // 在列表尾部添加元素
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }

    // 在指定位置插入元素
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }

    // 移除指定位置的元素
    public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        }
        elementData[--size] = null; // 让 GC 回收无用的引用
        return oldValue;
    }

    // 获取指定位置的元素
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    // 设置指定位置的元素
    public E set(int index, E element) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    // 返回列表的大小
    public int size() {
        return size;
    }

    // 确保数组容量足够
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

    // 扩容数组
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 如果需要扩容
        if (minCapacity - elementData.length > 0) {
            grow(minCapacity);
        }
    }

    // 扩容策略
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); // 扩大为原来的1.5倍

        // 检查是否超出最大容量
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            newCapacity = hugeCapacity(minCapacity);
        }

        // 将原数组的元素复制到新数组
        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;
    }

    // 获取指定位置的元素，不进行范围检查
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    // 其他可能的方法...
}