public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, Serializable {
    private static final long serialVersionUID = 8683452581122892189L;
    /** 默認(rèn)初始容量 */ 
    private static final int DEFAULT_CAPACITY = 10;
    /** 空實(shí)例數(shù)組（無(wú)延遲擴(kuò)容） */
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /** 默認(rèn)構(gòu)造后首次擴(kuò)容使用的空數(shù)組 */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    /** 閾值：最大數(shù)組大小 */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    /** 真正存儲(chǔ)元素的數(shù)組；構(gòu)造時(shí)或賦予 EMPTY_* 共享數(shù)組 */
    transient Object[] elementData;
    /** 當(dāng)前元素個(gè)數(shù) */
    private int size;
    /** 用于 Fail-Fast 的修改計(jì)數(shù)器 */
    protected transient int modCount;
    // …
}

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);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 延遲初始化：第一次調(diào)用 ensureCapacity 時(shí)，將容量至少設(shè)置為 DEFAULT_CAPACITY（10）
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 用于迭代時(shí)快速失敗
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {
    // 舊容量
    int oldCapacity = elementData.length;
    // 新容量 = 舊容量 + 舊容量>>1 （1.5 倍擴(kuò)容）
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 最大容量檢查（防止溢出）
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 指定初始容量大于0時(shí)
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}
// 無(wú)參構(gòu)造方法
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

public E remove(int index) {
    rangeCheck(index); // 檢查索引是否合法
    modCount++;        // 修改次數(shù)+1，支持 fail-fast
    E oldValue = elementData(index); // 獲取舊值
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
}

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    elementData[--size] = null;
}

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i] == null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size - 1; i >= 0; i--)
            if (elementData[i] == null)
                return i;
    } else {
        for (int i = size - 1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    int cursor = 0;       // 下一個(gè)要返回的元素索引
    int lastRet = -1;     // 上一個(gè)返回的元素索引，若沒(méi)有則為 -1
    int expectedModCount = modCount;  // 用于檢測(cè)并發(fā)修改
    public boolean hasNext() {
        return cursor != size;
    }
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }
    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount;
    }
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

ListIterator<String> it = list.listIterator();
while (it.hasNext()) {
    System.out.println(it.next());
}
while (it.hasPrevious()) {
    System.out.println(it.previous());
}

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorReverseDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Dog");
        list.add("Cat");
        list.add("Bird");
        list.add("Fish");
        System.out.println("原始列表: " + list);
        ListIterator<String> iterator = list.listIterator(list.size()); // 從末尾開始
        while (iterator.hasPrevious()) {
            String animal = iterator.previous();
            // 替換元素
            if (animal.equals("Cat")) {
                iterator.set("Tiger"); // 將 Cat 替換為 Tiger
            }
            // 刪除元素
            if (animal.equals("Bird")) {
                iterator.remove(); // 刪除 Bird
            }
            // 在 Fish 前插入一個(gè)元素
            if (animal.equals("Fish")) {
                iterator.add("Whale"); // 插入 Whale（在 Fish 之前）
            }
        }
        System.out.println("修改后的列表: " + list);
    }
}

List<Integer> list = new ArrayList<>();
Runnable task = () -> {
    for (int i = 0; i < 1000; i++) {
        list.add(i);  // 非線程安全
    }
};
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("最終大小: " + list.size()); // 不一定是 2000

List<Integer> syncList = Collections.synchronizedList(new ArrayList<>());
// 遍歷時(shí)手動(dòng)加鎖
synchronized(syncList) {
    for (Integer i : syncList) {
        // 安全遍歷
    }
}

List<String> cowList = new CopyOnWriteArrayList<>();