ArrayList、Vector、LinkedList源码

　　List接口的一些列实现中，最常用最重要的就是这三个：ArrayList、Vector、LinkedList。这里我就基于JDK1.7来看一下源码。

public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

public class Vector<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

public class LinkedList<E> extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

　从这三个类定义就可以看出一些信息：

• ArrayList、Vector继承了AbstractList这个抽象类，LinkedList继承了AbstractSequentialList
  这个抽象类，AbstractSequentialList 也是继承AbstractList，只不过它实现了get(int index)、
  set(int index, E element)、add(int index, E element) 和 remove(int index)这些骨干性函数，降低了List接口的复杂度；
• ArrayList和Vector都实现了RandomAccess接口，而LinkedList没有，这是什么意思呢？在JDK中，RandomAccess接口是一个空接口，
  所以它没有实际意义，就是一个标记，标记这个类支持快速随机访问，所以，arrayList和vector是支持随机访问的，但是LinkedList不支持；
• serializbale接口表名，他们都支持序列化。
  　　

　在这三个List实现类里面：　　

1. ArrayList和Vector使用了数组的实现，相当于封装了对数组的操作。这也正是他们能够支持快速随机访问的原因，
   在JDK中所有基于数组实现的数据结构都能够支持快速随机访问。ArrayList和Vector的实现上几乎都使用了相同的算法，
   他们的主要区别就是ArrayList没有对任何一个方法做同步，所以不是线程安全的；而Vector中大部分方法都做了线程同步，是线程安全的。

2. LinkedList使用的是非循环双向链表的数据结构（这是JDK1.7更新部分，LinkedList在1.7之前都是循环双向链表）。
   由于是基于链表的，所以是没法实现随机访问的，只能顺序访问，这也正式它没有实现RandomAccess接口的原因。

　　ArrayList和Vector方法实现基本一样，所以这里我就拿ArrayList和LinkedList来做对比。

一、add方法

1. ArrayList实现add

        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
   
        private void ensureCapacityInternal(int minCapacity) {
            if (elementData == 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 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);
        }

   第2行，如果数组空间不够，实现数组动态扩容，动态扩容在grow方法实现，第11行，JDK利用移位运算符进行扩容计算，>>1右移一位表示除2，所以newCapacity就是扩容为原来的1.5倍。（PS：JDK1.7中第11行是移位运算，而在JDK1.6中第11行是直接除2，所以说JDK1.7相比于JDK1.6代码优化了），然后数组空间足够大，然后在数组末尾增加元素并且通过后++完成add元素。

2. 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;
            if (l == null)
                first = newNode;
            else
                l.next = newNode;
            size++;
            modCount++;
        }

   代码中可以看到，LinkedList基于链表的，不需要扩容，直接把元素加到链表最后，把新元素的前节点指向之前的last元素后节点就ok了。

　　二、get方法

1. ArrayList实现get

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

   ArrayList的get方法比较方便，通过数组下标能够直接找到数据返回。

2. LinkedList实现get

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

   ArrayList的get方法需要遍历到具体位置，获得数据返回，这里为了提高效率，需要根据获取的位置判断是从头还是从尾开始遍历，将index与长度size的一半比较，如果index<size/2，就只从位置0往后遍历到位置index处，而如果index>size/2，就只从位置size往前遍历到位置index处即可。

　　三、remove方法

1. ArrayList实现remove

        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;
        }
   
        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; // clear to let GC do its work
        }

   ArrayList实现remove(int)和remove(Object)两种方式，通过System的arrayCopy方法实现元素的移动（本质上是数组的复制），remove(Object)方法实际上是先找到需要删除元素的下标，然后在实现删除功能，实际和remove(int)一样。

2. LinkedList实现remove

        public E remove(int index) {
            checkElementIndex(index);
            return unlink(node(index));
        }
   
        public boolean remove(Object o) {
            if (o == null) {
                for (Node<E> x = first; x != null; x = x.next) {
                    if (x.item == null) {
                        unlink(x);
                        return true;
                    }
                }
            } else {
                for (Node<E> x = first; x != null; x = x.next) {
                    if (o.equals(x.item)) {
                        unlink(x);
                        return true;
                    }
                }
            }
            return false;
        }
   
        E unlink(Node<E> x) {
            // assert x != null;
            final E element = x.item;
            final Node<E> next = x.next;
            final Node<E> prev = x.prev;
   
            if (prev == null) {
                first = next;
            } else {
                prev.next = next;
                x.prev = null;
            }
   
            if (next == null) {
                last = prev;
            } else {
                next.prev = prev;
                x.next = null;
            }
   
            x.item = null;
            size--;
            modCount++;
            return element;
        }

   LinkedList实现remove(int)和remove(Object)，不管是根据下标删除还是根据Object删除，都是先找到对应的Node,然后在删除，对应的上下数据节点改变。

　　四、总结

1. 对于查找get方法，ArrayList的效率是要比LinkedList高的，原因也是ArrayList是基于数组的，直接通过下标能找到，LinkedList则需要遍历到具体位置。
2. 增加add方法和删除remove方法，虽说链表的增加和删除效率比数组高，但是这也不是绝对，看具体情况，有几种极端情况，一种是在LinkedList和ArrayList的首位增加和删除，这种LinkedList效率好一点，如果在中间处增加和删除，这种的话ArrayList效率好一点，所以说增加add方法和删除remove方法说不上哪个效率高，这要看具体情况分析。