前言

由于LinkedList和CopyOnWriteArrayList的源码相对来说比较简单，就放在一起分析了。

LinkedList

就从下面一个例子开始分析

public static void main(String[] args) {
    List<String> list = new LinkedList<String>(); 
    List<String> l = new ArrayList<>() ;
    list.add("java");
    list.add("android");
    l.add("c++");
    l.add("python");
    list.addAll(0,l);
    System.out.println(list);
}

首先看默认构造函数:

// 没有做其他处理
public LinkedList() {
}

再看add()方法

public boolean add(E e) {
    linkLast(e);
    return true;
}

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    // 让当前节点作为尾节点
    last = newNode;
    // 判断当前链表是否为null,如果为null,则新加节点为头节点
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

这里需要注意下Node，这就是链表中每个节点的数据结构，我们后面会分析很多集合，都会见到Node的影子。而add()方法就比较简单了，创建一个Node节点，然后就是做下判断，往后面添加了。

private static class Node<E> {
    // 当前节点表示的值
    E item;
    // 下一节点
    Node<E> next;
    // 上一节点
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

再看下addAll()方法吧。

// index:表示要添加的位置
public boolean addAll(int index, Collection<? extends E> c) {
    // 检查集合要添加的位置是否合法
    checkPositionIndex(index);
    // 将集合转为数组
    Object[] a = c.toArray();
    // 获取数组长度
    int numNew = a.length;
    if (numNew == 0)
        return false;
    // pred:标记要添加元素的前一个位置元素;succ:对应index位置的元素
    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }
    // 遍历数组,创建结点对象,判断要添加元素的前一个位置的元素是否为null,如果
    // 为null,则第一个元素则为first,否则将其赋值个.next元素
    
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }
    // 元素添加完了之后,处理“切口处”
    // 判断对应index元素是否为null,如果为null,则pred为最后一个元素,否则,对应index元素为最后添加元素的next
    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

上面注释已经比较清楚了，学过数据结构的应该很容易看懂。

CopyOnWriteArrayList

我们都知道CopyOnWriteArrayList是并发包的一个类，它是线程安全的。我们可以一边遍历一边去删除该集合里面的元素。

底层数据结构也是一个object数组。

private transient volatile Object[] array;

public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<String>() ;
        list.add("java");
        list.add("c");
        list.add("c#");
    }

我们先看构造函数

public CopyOnWriteArrayList() {
     setArray(new Object[0]);
 }
final void setArray(Object[] a) {
    array = a;
}

从这可以看出，默认构造函数给array一个大小为0的object数组。

再看add()方法吧

public boolean add(E e) {
    // 使用类定义的锁,在同一个时刻只能执行add/remove/set其中的一个
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

从上面可以知道，我们每次调用一次add()方法，开始前上锁，然后都会进行一次数组的拷贝。（是否会有些性能问题呢？），最后释放锁。整个过程比较简单。（相对于并发Map来说真是很简单了）

我们再来看一个方法

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取源数组
        Object[] elements = getArray();
        // 数组长度
        int len = elements.length;
        // 获取数组index对应的值
        E oldValue = get(elements, index);
        // 计算数组拷贝的长度
        int numMoved = len - index - 1;
        if (numMoved == 0)
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            // 创建新数组
            Object[] newElements = new Object[len - 1];
            // 将源数组0-index拷贝到新数组
            System.arraycopy(elements, 0, newElements, 0, index);
            // 将源数组index+1的长度为 numMoved的数据拷贝到新数组
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            setArray(newElements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

上面重要的几行代码进行了注释，从上面看，每次调用remove方法，它也是会进行数组的拷贝。

再看set()方法

public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            E oldValue = get(elements, index);

            if (oldValue != element) {
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

上面代码比较简单，也是通过数组的拷贝来实现功能的。