java1.7集合源码阅读：ArrayList

ArrayList是jdk1.2开始新增的List实现，首先看看类定义：

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

ArrayList实现List接口，上层接口是Collection，顶级接口是Iterable，同时还实现了Cloneable、Serializable、RandomAccess接口，以支持克隆、序列化、快速访问。

ArrayList初始容量为10，同时也支持初始化指定初始容量以及使用另一个集合作为初始参数，真正存储数据的是：

     private transient Object[] elementData;
     ......
   public ArrayList(int initialCapacity) {
         super();
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal Capacity: "+
                                                initialCapacity);
         this.elementData = new Object[initialCapacity];
     }

ArrayList内部以数组结构存储数据，相关add、get等方法基本上都是对数组的相关操作，但在增删操作的时候会进行边界检查，增加操作时还要验证容量，当容量不够时会进行扩容.
验证边界:

   private void rangeCheck(int index) {
         if (index >= size)
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     /**
      * A version of rangeCheck used by add and addAll.
      */
     private void rangeCheckForAdd(int index) {
         if (index > size || index < 0)
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

容量验证及扩容：

   /**
      * Increases the capacity of this <tt>ArrayList</tt> instance, if
      * necessary, to ensure that it can hold at least the number of elements
      * specified by the minimum capacity argument.
      *
      * @param   minCapacity   the desired minimum capacity
      */
     public void ensureCapacity(int minCapacity) {
         int minExpand = (elementData != EMPTY_ELEMENTDATA)
             // any size if real element table
             ? 0
             // larger than default for 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 == 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);
     }

扩容时，为原容量的1.5倍。

ArrayList对Iterator接口的实现：

   /**
      * An optimized version of AbstractList.Itr
      */
     private class Itr implements Iterator<E> {
         int cursor;       // index of next element to return
         int lastRet = -1; // index of last element returned; -1 if no such
         int expectedModCount = modCount;

         public boolean hasNext() {
             return cursor != size;
         }

         @SuppressWarnings("unchecked")
         public E next() {
             checkForComodification();
             int i = cursor;
             if (i >= size)
                 throw new NoSuchElementException();
             Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length)
                 throw new ConcurrentModificationException();
             cursor = i + 1;
             return (E) elementData[lastRet = i];
         }

         public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

             try {
                 ArrayList.this.remove(lastRet);
                 cursor = lastRet;
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }

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

当对ArrayList进行for循环时，如有对集合进行增删改操作时，会报产生ConcurrentModificationException异常。

特别注意：ArrayList不是线程安全的，存在线程安全问题可使用Vector。