public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    // 加鎖，用來(lái)保證線程安全
    final transient ReentrantLock lock = new ReentrantLock();

    // 存儲(chǔ)元素的數(shù)組，使用了volatile修飾
    private transient volatile Object[] array;

    // 數(shù)組的get/set方法
    final Object[] getArray() {
        return array;
    }
    final void setArray(Object[] a) {
        array = a;
    }

}

List<Integer> list = new CopyOnWriteArrayList<>();

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

// 添加元素
public boolean add(E e) {
    // 加鎖，保證線程安全
    final ReentrantLock lock = this.lock;
    lock.lock();

    try {
        // 獲取原數(shù)組
        Object[] elements = getArray();
        int len = elements.length;
        // 創(chuàng)建一個(gè)新數(shù)組，長(zhǎng)度原數(shù)組長(zhǎng)度+1，并把原數(shù)組元素拷貝到新數(shù)組里面
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 直接賦值給新數(shù)組末尾位置
        newElements[len] = e;
        // 替換原數(shù)組
        setArray(newElements);
        return true;
    } finally {
        // 釋放鎖
        lock.unlock();
    }
}

// 按照下標(biāo)刪除元素
public E remove(int index) {
    // 加鎖，保證線程安全
    final ReentrantLock lock = this.lock;
    lock.lock();

    try {
        // 獲取原數(shù)組
        Object[] elements = getArray();
        int len = elements.length;
        E oldValue = get(elements, index);
        // 計(jì)算需要移動(dòng)的元素個(gè)數(shù)
        int numMoved = len - index - 1;
        if (numMoved == 0) {
            // 0表示刪除的是數(shù)組末尾的元素
            setArray(Arrays.copyOf(elements, len - 1));
        } else {
            // 創(chuàng)建一個(gè)新數(shù)組，長(zhǎng)度是原數(shù)組長(zhǎng)度-1
            Object[] newElements = new Object[len - 1];
            // 把原數(shù)組下標(biāo)前后兩段的元素都拷貝到新數(shù)組里面
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                numMoved);
            // 替換原數(shù)組
            setArray(newElements);
        }
        return oldValue;
    } finally {
        // 釋放鎖
        lock.unlock();
    }
}

// 批量刪除元素
public boolean removeAll(Collection<?> c) {
    // 參數(shù)判空
    if (c == null) {
        throw new NullPointerException();
    }
    // 加鎖，保證線程安全
    final ReentrantLock lock = this.lock;
    lock.lock();

    try {
        // 獲取原數(shù)組
        Object[] elements = getArray();
        int len = elements.length;
        if (len != 0) {
            // 創(chuàng)建一個(gè)新數(shù)組，長(zhǎng)度暫時(shí)使用原數(shù)組的長(zhǎng)度，因?yàn)椴恢酪獎(jiǎng)h除多少個(gè)元素。
            Object[] temp = new Object[len];
            // newlen表示新數(shù)組中元素個(gè)數(shù)
            int newlen = 0;
            // 遍歷原數(shù)組，把需要保留的元素放到新數(shù)組中
            for (int i = 0; i < len; ++i) {
                Object element = elements[i];
                if (!c.contains(element)) {
                    temp[newlen++] = element;
                }
            }
            // 如果新數(shù)組沒(méi)有滿，就釋放空白位置，并覆蓋原數(shù)組
            if (newlen != len) {
                setArray(Arrays.copyOf(temp, newlen));
                return true;
            }
        }
        return false;
    } finally {
        // 釋放鎖
        lock.unlock();
    }
}

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class Test {

    public static void main(String[] args) {
        List<Integer> list = new CopyOnWriteArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        // 遍歷ArrayList
        for (Integer key : list) {
            // 判斷如果元素等于2，則刪除
            if (key.equals(2)) {
                list.remove(key);
            }
        }
        System.out.println(list);
    }

}

[1, 3]

static final class COWIterator<E> implements ListIterator<E> {
    /**
     * 原數(shù)組的快照
     */
    private final Object[] snapshot;
    /**
     * 迭代游標(biāo)
     */
    private int cursor;

    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }

    public boolean hasNext() {
        return cursor < snapshot.length;
    }

    // 迭代下個(gè)元素
    public E next() {
        if (!hasNext())
            throw new NoSuchElementException();
        return (E)snapshot[cursor++];
    }
}