// 基于本地 JDK 源码 (java.base, JDK 21+ 代码线), java.util.ArrayList —— 按位读写与删除
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // ...

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];    // 泛型擦除后数组是 Object[]，读出来强转，@SuppressWarnings 收敛在此一处
    }

    public E get(int index) {
        Objects.checkIndex(index, size);    // 按 size 检查而不是数组长度，容量内但 >= size 的位置照样越界
        return elementData(index);          // O(1)，RandomAccess 的底气
    }

    public E set(int index, E element) {
        Objects.checkIndex(index, size);
        E oldValue = elementData(index);
        elementData[index] = element;    // 全程不碰 modCount：set 不是结构性修改，迭代期间 set 不会触发 fail-fast
        return oldValue;
    }

    // 头部/中间插入触发 arraycopy 搬动后续所有元素，越靠前越慢，这就是"中间增删 O(n)"的来源
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        modCount++;
        final int s;
        Object[] elementData;
        if ((s = size) == (elementData = this.elementData).length)
            elementData = grow();
        System.arraycopy(elementData, index,
                         elementData, index + 1,
                         s - index);         // [index, size) 整体后移一位腾位置
        elementData[index] = element;
        size = s + 1;
    }

    public E remove(int index) {
        Objects.checkIndex(index, size);
        final Object[] es = elementData;

        @SuppressWarnings("unchecked") E oldValue = (E) es[index];
        fastRemove(es, index);

        return oldValue;
    }

    // 按值删除：只删第一个匹配。注意 list.remove(1) 走上面按下标的重载，Integer 列表想按值删要 remove(Integer.valueOf(1))
    public boolean remove(Object o) {
        final Object[] es = elementData;
        final int size = this.size;
        int i = 0;
        found: {
            if (o == null) {                 // null 单独一条路，因为 null.equals 会 NPE，所以 ArrayList 允许存 null
                for (; i < size; i++)
                    if (es[i] == null)
                        break found;
            } else {
                for (; i < size; i++)
                    if (o.equals(es[i]))     // 方向是 参数.equals(元素)，元素侧的 equals 不会被调用
                        break found;
            }
            return false;                    // 没找到，modCount 不动
        }
        fastRemove(es, i);
        return true;
    }

    private void fastRemove(Object[] es, int i) {
        modCount++;
        final int newSize;
        if ((newSize = size - 1) > i)
            System.arraycopy(es, i + 1, es, i, newSize - i);    // [i+1, size) 前移覆盖被删元素
        es[size = newSize] = null;    // 末位置 null 帮 GC，否则残留引用让对象无法回收（逻辑删除但物理还挂着）
    }
}

// 基于本地 JDK 源码 (java.base, JDK 21+ 代码线), java.util.ArrayList —— fail-fast 迭代器
public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;    // 创建迭代器时拍下的"修改快照"

    // ...

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();    // 每次 next 先验快照
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();    // 兜底：并发下数组引用可能已被换成更短的（如 trimToSize），快照来不及发现
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();    // 还没 next 过、或已删过一次，没有"上一个元素"可删
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;                     // 后续元素前移了一位，游标退回去才不漏元素
            lastRet = -1;
            expectedModCount = modCount;          // 关键：同步快照。这就是"边遍历边删必须用 it.remove()"的原因
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    // ...

    final void checkForComodification() {
        if (modCount != expectedModCount)    // 快照对不上 = 迭代期间有别的途径做了结构性修改
            throw new ConcurrentModificationException();
    }
}