java容器二：List接口实现类源码分析

一、ArrayList

1、存储结构

动态数组elementData

transient Object[] elementData;

除此之外还有一些数据

     //默认初始容量
     private static final int DEFAULT_CAPACITY = 10;

     //共享空数组
     private static final Object[] EMPTY_ELEMENTDATA = {};

     //默认初始空数组
     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     //动态数组中对象数量
     private int size;

EMPTY_ELEMENTDATA（下面简称EE）和DEFAULTCAPICITY_EMPTY+ELEMENTDATA（以下简称DEE）作用与区别

1、当用无参构造器构造一个ArrayList实例时,使用DEE

     /**
      * Constructs an empty list with an initial capacity of ten.
      * 无参构造器：将DEE空数组传递给elementData
      */
     public ArrayList() {
         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
     }

2、当使用传入初始容量但是大小为0的构造器构造一个空ArrayList实例时，使用EE

 　　/**
      * Constructs an empty list with the specified initial capacity.
      *有参构造器，判断传入的数组大小，若为有效数字且不为0则根据传递的值构造一个数组
      * 若传入的为0，则将EE空数组给elementData
      * 若传入的为无效数字，则抛出异常
      * @param  initialCapacity  the initial capacity of the list
      * @throws IllegalArgumentException if the specified initial capacity
      *         is negative
      */
     public ArrayList(int initialCapacity) {
         if (initialCapacity > 0) {
             this.elementData = new Object[initialCapacity];
         } else if (initialCapacity == 0) {
             this.elementData = EMPTY_ELEMENTDATA;
         } else {
             throw new IllegalArgumentException("Illegal Capacity: "+
                                                initialCapacity);
         }
     }

3、区别：作用不同
DEE空数组是无参构造器中调用，后来增加第一个元素时扩容为默认大小10
EE是在构造出空数组（传入有参参数0）时调用，它的作用在于使得所有ArrayList空实例都指向同一个对象也就是EE

2、get/set方法

     public E get(int index) {
         Objects.checkIndex(index, size);
         return elementData(index);
     }

     public E set(int index, E element) {
         Objects.checkIndex(index, size);
         E oldValue = elementData(index);
         elementData[index] = element;
         return oldValue;
     }

3、add方法

（1）在尾部添加一个元素add(E e)

     public boolean add(E e) {
         modCount++;
         add(e, elementData, size);
         return true;
     }

     private void add(E e, Object[] elementData, int s) {
         if (s == elementData.length)
             elementData = grow();
         elementData[s] = e;
         size = s + 1;
     }

（2）在指定位置上添加一个元素add(int index,E e)

     public void add(int index, E element) {
         rangeCheckForAdd(index);
         modCount++;
         final int s;
         Object[] elementData;
         if ((s = size) == (elementData = this.elementData).length)
             elementData = grow();
         System.arraycopy(elementData, index,
                          elementData, index + 1,
                          s - index);
         elementData[index] = element;
         size = s + 1;
     }

（3）grow方法：在两个add方法中都会在插入元素之前检查数组容量是否足够，若不足则需要扩容

     private Object[] grow(int minCapacity) {
         return elementData = Arrays.copyOf(elementData,
                                            newCapacity(minCapacity));
     }

     private Object[] grow() {
         return grow(size + 1);
     }

     private int newCapacity(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         //重点步骤
         int newCapacity = oldCapacity + (oldCapacity >> 1);
         if (newCapacity - minCapacity <= 0) {
             if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                 return Math.max(DEFAULT_CAPACITY, minCapacity);
             if (minCapacity < 0) // overflow
                 throw new OutOfMemoryError();
             return minCapacity;
         }
         return (newCapacity - MAX_ARRAY_SIZE <= 0)
             ? newCapacity
             : hugeCapacity(minCapacity);
     }    

4、remove方法

（1）移除某一位置上的对象remove(int index)

     public E remove(int index) {
         Objects.checkIndex(index, size);

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

（2）移除某一对象remove(Object o)

 　　//遍历找到o的位置，然后移除，这里的fastRemove方法相对于上面的remove方法少了index验证的步骤，因为能够找到要被删除元素的index则index一定合理
 　　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;
     }

5、序列化

ArrayList接口是实现了Serializable接口的，说明是可以序列化的

但是我们在前面已经看到保存对象集合的elementData用transient修饰，是不被序列化的

这是因为elementData为了后续扩容会保存一定的容量，为了避免序列化这部分内容，序列化就采取上诉的方式用readObject和writeObject方法来序列化

     private void readObject(java.io.ObjectInputStream s)
         throws java.io.IOException, ClassNotFoundException {

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

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

         if (size > 0) {
             // like clone(), allocate array based upon size not capacity
             SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Object[].class, size);
             Object[] elements = new Object[size];

             // Read in all elements in the proper order.
             for (int i = 0; i < size; i++) {
                 elements[i] = s.readObject();
             }

             elementData = elements;
         } else if (size == 0) {
             elementData = EMPTY_ELEMENTDATA;
         } else {
             throw new java.io.InvalidObjectException("Invalid size: " + size);
         }
     }

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

二、Vector

Vector和ArrayList操作基本相同，只不过对方法加了synchronized做同步处理,以add方法为例

     //add1
     public synchronized boolean add(E e) {
         modCount++;
         add(e, elementData, elementCount);
         return true;
     }

     //add2
     public void add(int index, E element) {
         insertElementAt(element, index);
     }

     public synchronized void insertElementAt(E obj, int index) {
         if (index > elementCount) {
             throw new ArrayIndexOutOfBoundsException(index
                                                      + " > " + elementCount);
         }
         modCount++;
         final int s = elementCount;
         Object[] elementData = this.elementData;
         if (s == elementData.length)
             elementData = grow();
         System.arraycopy(elementData, index,
                          elementData, index + 1,
                          s - index);
         elementData[index] = obj;
         elementCount = s + 1;
     }

     //扩容重点步骤：确定扩容的大小
     private int newCapacity(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                          capacityIncrement : oldCapacity);
         if (newCapacity - minCapacity <= 0) {
             if (minCapacity < 0) // overflow
                 throw new OutOfMemoryError();
             return minCapacity;
         }
         return (newCapacity - MAX_ARRAY_SIZE <= 0)
             ? newCapacity
             : hugeCapacity(minCapacity);
     }

三、LinkedList

1、存储结构

双向链表存储，有一个头结点first，一个尾节点last,每一个节点有两个指针，一个指向它的前驱节点，一个指向它的后继节点

     /**
      * Pointer to first node.
      */
     transient Node<E> first;

     /**
      * Pointer to last node.
      */
     transient Node<E> last;

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

2、get/set方法

     public E get(int index) {
         checkElementIndex(index);
         return node(index).item;
     }

     /**
      * Returns the (non-null) Node at the specified element index.
      * 用二分法简单判断一下对象在链表前半部分还是后半部分
      * 决定是从first指针向后遍历还是last指针向前遍历
      */
     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;
         }
     }

     public E set(int index, E element) {
         checkElementIndex(index);
         Node<E> x = node(index);
         E oldVal = x.item;
         x.item = element;
         return oldVal;
     }

3、add方法

 /**
      * 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++;
     }

     /**
      * Inserts element e before non-null Node succ.
      */
     void linkBefore(E e, Node<E> succ) {
         // assert succ != null;
         final Node<E> pred = succ.prev;
         final Node<E> newNode = new Node<>(pred, e, succ);
         succ.prev = newNode;
         if (pred == null)
             first = newNode;
         else
             pred.next = newNode;
         size++;
         modCount++;
     }

4、remove方法

     /**
      * Unlinks non-null last node l.
      */
     private E unlinkLast(Node<E> l) {
         // assert l == last && l != null;
         final E element = l.item;
         final Node<E> prev = l.prev;
         l.item = null;
         l.prev = null; // help GC
         last = prev;
         if (prev == null)
             first = null;
         else
             prev.next = null;
         size--;
         modCount++;
         return element;
     }

四、线程安全解决方案

ArrayList和LinkedList都是线程不安全的，因此若想要实现线程安全有一下替换的实现方案

方案一：用Collections.synchronizedList()方法构造出一个线程安全的list（ArrayList和LinkedList都可以使用）

List<String> synList1 = Collections.synchronizedList(new ArrayList<>());

List<String> synList2 = Collections.synchronizedList(new LinkedList<>());

方案二：用java..concurrent包下面的CopyOnWriteArrayList替代ArrayList

CopyOnWriteArrayList：重点是读写分离

1、原理：

写操作的时候会在一个复制的数组上进行，并且要加锁

读操作在原数组上进行

写操作完毕之后，读操作的数组指针指向新的复制数组

2、关键代码

写操作

     public boolean add(E e) {
         synchronized (lock) {
             Object[] elements = getArray();
             int len = elements.length;
             Object[] newElements = Arrays.copyOf(elements, len + 1);
             newElements[len] = e;
             setArray(newElements);
             return true;
         }
     }

     public E remove(int index) {
         synchronized (lock) {
             Object[] elements = getArray();
             int len = elements.length;
             E oldValue = elementAt(elements, index);
             int numMoved = len - index - 1;
             if (numMoved == 0)
                 setArray(Arrays.copyOf(elements, len - 1));
             else {
                 Object[] newElements = new Object[len - 1];
                 System.arraycopy(elements, 0, newElements, 0, index);
                 System.arraycopy(elements, index + 1, newElements, index,
                                  numMoved);
                 setArray(newElements);
             }
             return oldValue;
         }
     }

读操作

    public E get(int index) {
        return elementAt(getArray(), index);
    }

3、应用场景

因为CopyOnWriteArrayList允许读写同时进行，大大提高了读操作的性能，因此适用于读多写少的应用场景

4、缺点

（1）内存占用：有一个复制的写数组，因此内存占用增加了一倍

（2）数据不一致：读操作不能实时性得到写操作数据

因此不适合与内存敏感、实时性要求高的应用场景

方案三：用Vector替代ArrayList

五、ArrayList与Vector、LinkedList比较

1、ArrayList与Vector比较

（1）ArrayList是线程不安全的，因此读写效率高，Vector是线程安全的

（2）扩容时ArrayList扩大为原来的1.5倍，Vector扩大为原来的2倍

2、ArrayList与LinkedList比较

（1）ArrayList是用动态数组实现，LinkedList是用双向链表实现

（2）ArrayList支持随机访问，LinkedList不支持

（3）LinkedList插入删除更快