java.util.ArrayList、java.util.vector和java.util.LinkedList （JDK 1.8.0_111）

一、java.util.ArrayList

1.1 ArrayList 继承结构

ArrayList实现了RandomAccess，可以随机访问（其实就是通过数组下标访问）；实现了Cloneable，可以拷贝（通过System.arraycopy方法实现）；实现了Serializable，可以进行序列化，能被序列化传输。

ArrayList非线程安全。

1.2 ArrayList 属性

    private static final long serialVersionUID = 8683452581122892189L;
    // 初始化容量
    private static final int DEFAULT_CAPACITY = 10;
    // 共享空的数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    // 共享一个具有初始化容量的数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 核心数组
    transient Object[] elementData; // non-private to simplify nested class access
    // 数组存放元素总数
    private int size;

1.3 ArrayList 方法

    // 确保Capacity能达到指定的minCapacity
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    // 数组可以分配的最大长度
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    // 扩容
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 扩容为之前的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        // 将原数组内容拷贝到扩容后数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

上面是ensureCapacity方法，确保Capacity能大于等于minCapacity。ArrayList每次扩容为之前的1.5倍。

    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

拷贝ArrayList方法，这也不是一种深度拷贝，只是将源数组的内容拷贝到新数组，元素并未重建（拷贝）。

    public void add(int index, E element) {
        rangeCheckForAdd(index);
        // 确保容量足够
        ensureCapacityInternal(size + 1);  // Increments modCount !!
        // 将index及其后元素统统向后移动一位 
        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; // clear to let GC do its work

        return oldValue;
    }

ArrayList其根本是个数组，因此在数组末尾增删元素是很高效的。但是要在中间增删元素，就必须移动后面的所有元素，效率肯定会有影响。

如果需要频繁向中间增删元素还是LinkedList比较合适。

    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;
    }

remove某个value，找到第一个value之后，就删除并return。

    // 将ArrayList写入到ObjectOutputStream
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        // 将非静态和非transient字段写入流
        s.defaultWriteObject();

        // 将size写入流
        s.writeInt(size);

        // 将所有的元素写入流中
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // 从流中读入非静态和非transient字段
        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // 读入size
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            // 读取元素
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

这两个方法将ArrayList写入流或者从流中读入。但是我有个疑问，都是private方法，这个写出来谁能调用？ 

二、java.util.Vector

2.1 Vector 继承结构

Vector继承结构和ArrayList相同。ArrayList是非线程安全的，与之对应的Vector是线程安全的。

2.2 Vector 属性

    // 存储对象的数组
    protected Object[] elementData;
    // 可以理解为Vector的capacity，也可以理解为数组的length
    protected int elementCount;
    // 可以自定义capacity扩容量
    protected int capacityIncrement;
    private static final long serialVersionUID = -2767605614048989439L;

2.3 Vector 方法

扩容方法

    public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            // 注意这里会导致modCount++ !!
            modCount++;   
            ensureCapacityHelper(minCapacity);
        }
    }

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            // 需要扩容处理
            grow(minCapacity);
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 如果没有自定义扩容增量capacityIncrement，则直接扩容为之前的容量的两倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            // 扩容为之前容量的两倍如果还不够，则直接扩容为minCapacity
            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) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

ensureCapacity方法加了synchronized同步锁。在扩容策略上跟ArrayList稍有不同，ArrayList默认扩容为之前容量的1.5倍，而Vector则默认扩容为之前容量的2倍。除此之外Vector还允许自定义扩容增量。

    public synchronized List<E> subList(int fromIndex, int toIndex) {
        return Collections.synchronizedList(super.subList(fromIndex, toIndex),
                                            this);
    }

在subList方法中，为了返回一个线程安全的List，加上了Collections.synchronizedList封装。

If you need synchronization, a Vector will be slightly faster than an ArrayList synchronized with Collections.synchronizedList.

Collections.synchronizedList封装是对List对象添加同步锁，各方法本质上还是调用的List的方法。

Vector类其他方法和ArrayList差不多，无非加上了一个synchronized同步处理，这里就不再赘述了。 

三、java.util.LinkedList

3.1 LinkedList继承结构

LinkedList没有实现RandomAccess interface，可见其并不具备随机访问特性，毕竟是链表。

LinkedList同样是非线程安全的。

LinkedList比较适合从中间删除、添加元素的场景；ArrayList则更适合只在末尾增删元素，遍历的场景。

3.2 LinkedList 属性

    transient int size = 0;
    // 指向第一个节点
    transient Node<E> first;
    // 指向最后一个节点
    transient Node<E> last;

其中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;
        }
    }

Node节点包含next和prev两个指针，分别指向前面和后面的一个节点。

3.3 LinkedList 方法

    public E set(int index, E element) {
        // 检查index是否在范围内
        checkElementIndex(index);
        // 找出这个node节点
        Node<E> x = node(index);
        // 保存旧的值
        E oldVal = x.item;
        // 更新值
        x.item = element;
        return oldVal;
    }

    Node<E> node(int index) {
        // assert isElementIndex(index);
        // 如果index指向链表前半部分，则从前向后遍历
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            // index指向链表的后半部分，从后往前遍历
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

在这个set方法中，有个参数是index，修改指定index上的元素内容，但链表本身是不具备index属性的，为此通过node()方法遍历（从first向last方向开始计数）找到第index个Node，即为需要修改的节点。

node方法为了提高效率，根据index所指向的位置，从前向后或从后向前遍历，因此最多遍历size/2个节点就可以找到index节点了。

    // 获取第一个节点内容，但是不删除
    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

    // 获取第一个节点内容并且删除之
    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    // 删除第一个节点并返回其内容，跟poll一样
    public E pop() {
        return removeFirst();
    }

    // 添加一个元素到结尾
    public boolean offer(E e) {
        return add(e);
    }

    // 添加一个元素到开头
    public void push(E e) {
        addFirst(e);
    }

上面是几个比较容易混淆的方法，其实看下代码就明白了。

    private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());
        public boolean hasNext() {
            return itr.hasPrevious();
        }
        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
    }

LinkedList提供了一个反向迭代器，因为LinkedList本身就是一个双向链表，反向遍历也是很方便的。

    private LinkedList<E> superClone() {
        try {
            return (LinkedList<E>) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }
    }

    public Object clone() {
        LinkedList<E> clone = superClone();

        // Put clone into "virgin" state
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;

        // Initialize clone with our elements
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);

        return clone;
    }

拷贝方法，同样是浅拷贝，每个节点的元素内容并没有被拷贝。拷贝出来的结果是两个链表都引用的同一个元素内容。