Vectory、ArrayList、LinkedList底层详解

在Java里面，我们是不需要自己动手去实现一个动态数组、链表的，这也为我们大大的提高了生产率，使我们能够更专注于业务代码的逻辑实现上。在我们在日常工作中，会频繁使用集合。区分它们之间的差别，也是在日常开发中有效管理数据类型和功能特性的基础。在本章想讨论的内容，Vectory为何性能低下，ArrayList是如何实现动态扩容的，以及LinkedList双向链表是如何实现的，在此分享给大家。

Vector是Java早期提供的线程安全的动态数组，但是在开发中几乎不怎么使用它，具体原因就是它的性能非常低下，OK我们来看看它的设计源码具体实现，我们就能够知道原因了。
我们来看一看，它是如何操作的

//插入元素
//我们可以看到这段代码加了一个synchronized同步锁，虽然它可以保障数据在多线程环境下是安全的，
//如果不是需要线程安全，并不建议选择，毕竟同步是有额外开销的。
public synchronized boolean add(E e) {
        modCount++;
       
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

//指定下标插入 
public void add(int index, E element) {
        insertElementAt(element, index);
 }
    
public synchronized void insertElementAt(E obj, int index) {
        modCount++;
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        ensureCapacityHelper(elementCount + 1);
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        elementData[index] = obj;
        elementCount++;
    }

private void ensureCapacityHelper(int minCapacity) {
        //把所有元素的总数+1，如果传递进来的总数大于数组的长度，则需要扩容。
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
private void grow(int minCapacity) {
        // 扩容方法
        int oldCapacity = elementData.length;
        //如果Vectory的capacityIncrement ，在初始化的时候，
        //可以定义究竟该容纳多少元素，否则默认按照两倍进行扩容。
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        //如果扩容后的长度仍然小于传递进来的长度，则按照传递进来的元素为新的长度。
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //数组不能够超过虚拟机的长度限制
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
         //拷贝原有数组数据
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

相信你看到这里，应该明白了为什么Vector不怎么受欢迎的原因了吧。我们继续往下走，来看看ArrayList。

ArrayList是应用更加广泛的动态数组实现，它本身不是线程安全的，所以性能要好很多。与Vector近似，ArrayList也是可以根据需要调整容量，不过两者的调整逻辑有所区
别，Vector在扩容时如果你没有在此之前指定它会提高1倍，而ArrayList则是增加50%，我们来看看源码。

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
//老套路，首先进行校验，是否需要扩容，将插入的值放到尾部，并将 size + 1 
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++;
    }
 
//是不是有一种似曾相识的感觉，没错，其实原理机制差不多。
//把 index 位置空出来放本次插入的数据，并将后面的数据向后移动一个位置。
//  这是一个数组复制的过程
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

由此可见 ArrayList 的主要消耗是数组扩容以及在指定位置添加数据，在日常使用时最好是指定大小，尽量减少扩容。更要减少在指定位置插入数据的操作。

由于 ArrayList 是基于动态数组实现的，所以并不是所有的空间都被使用。因此使用了 transient 修饰，可以防止被自动序列化。

 private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        //只序列化了被使用的数据
        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;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, 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();
            }
        }
    }

当对象中自定义了 writeObject 和 readObject 方法时，JVM 会调用这两个自定义方法来实现序列化与反序列化。从实现中可以看出 ArrayList 只序列化了被使用的数据。

接下来我们来看看最后一个，LinkedList

LinkedList如图所示，它的底层是基于双向链表实现的，所以它不需要像上面两种那样调整容量，它也不是线程安全的，也是实现了 List 接口，所以也拥有 List 的一些特点(JDK1.7/8 之后取消了循环，修改为双向链表)，我们来看看它的增加和查询方法。

//增加
public boolean add(E e) {
        linkLast(e);
        return true;
    }
     /**
     * Links e as last element.
     */
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
//可见每次插入都是移动指针，和 ArrayList 的拷贝数组来说效率要高上不少。

//查询
 public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    
    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
 
// 上述代码，利用了双向链表的特性，如果index离链表头比较近，就从节点头部遍历。
//否则就从节点尾部开始遍历。使用空间（双向链表）来换取时间。
//node()会以O(n/2)的性能去获取一个结点
// 如果索引值大于链表大小的一半，那么将从尾结点开始遍历
//这样的效率是非常低的，特别是当 index 越接近 size 的中间值时。

总结：
Vector
有序，早期提供的线程安全动态数组，但是性能开销会比ArrayList大
ArrayList
有序、底层是数组，查询快、增删改慢、扩容呈现50%递增，而Vector呈现一倍方式递增。
LinkedList
有序、底层是双向链表链表、查询慢、增删改快。