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方法说不上哪个效率高，这要看具体情况分析。