-1，ArrayList继承AbstractList抽象类，实现List、RandomAccess、Cloneable、Serializable接口。
-2，查看List接口的继承关系，我们看到List接口实现了Collection接口。Collection接口是基本集合类接口。查看Collection接口的说明：
/*** The root interface in the <i>collection hierarchy</i>. A collection* represents a group of objects, known as its <i>elements</i>. Some* collections allow duplicate elements and others do not. Some are ordered* and others unordered.
-3，查看AbstractList分支继承关系，AbstractList继承AbstractCollection，实现List接口。
-4，查看AbstractCollection，可以看到该类实现Collection接口。
-5，Collection接口最终实现迭代器接口：Iterable。
2，从用自上而下的方式来一步一步查看源码。
3，Iterable接口：
package java.lang;import java.util.Iterator;/** Implementing this interface allows an object to be the target of* the "foreach" statement.* @since 1.5*/public interface Iterable<T> {/*** Returns an iterator over a set of elements of type T.** @return an Iterator.*/Iterator<T> iterator();}
Iterable接口类源码很简单，我们知道该接口属于迭代器模式，用来实现迭代遍历集合类。所以Collection接口实现了该接口，标识Collecttion的所有子类都可以使用迭代器方式遍历。
Iterable接口比较重要的子类我们可以看Iterator接口，如下，我摘录出了该接口的方法。
public interface Iterator<E> {boolean hasNext();E next();void remove();}
4，Collection接口，我们通过JavaDoc文档可以查看对应的子类
* <p>This interface is a member of the* <a href="{@docRoot}/../technotes/guides/collections/index.html">* Java Collections Framework</a>.** @author Josh Bloch* @author Neal Gafter* @version 1.55, 04/21/06* @see Set* @see List* @see Map* @see SortedSet* @see SortedMap* @see HashSet* @see TreeSet* @see ArrayList* @see LinkedList* @see Vector* @see Collections* @see Arrays* @see AbstractCollection* @since 1.2*/
可以看到对应的都实现此接口，接口中定义了集合类常用到的方法。
5，AbstractCollection
public abstract class AbstractCollection<E> implements Collection<E>
该类主要实现了部分共用的方法，比如：
/*** {@inheritDoc}** <p>This implementation returns <tt>size() == 0</tt>.*/public boolean isEmpty() {return size() == 0;}
public boolean contains(Object o) {Iterator<E> e = iterator();if (o==null) {while (e.hasNext())if (e.next()==null)return true;} else {while (e.hasNext())if (o.equals(e.next()))return true;}return false;}
public boolean remove(Object o) {Iterator<E> e = iterator();if (o==null) {while (e.hasNext()) {if (e.next()==null) {e.remove();return true;}}} else {while (e.hasNext()) {if (o.equals(e.next())) {e.remove();return true;}}}return false;}
public boolean addAll(Collection<? extends E> c) {boolean modified = false;Iterator<? extends E> e = c.iterator();while (e.hasNext()) {if (add(e.next()))modified = true;}return modified;}
主要实现了以上的方法，我们发现以上方法有个共同特点，就是具体操作是通过其他方法来实现的，比如addAll方法，主要是通过add方法来实现的。
6，List接口，List接口继承了Collection接口，对Collection接口进行了一些扩展。
-1，因为List存储的是顺序集合类。
An ordered collection (also known as a <i>sequence</i>).
-2，允许重复元素。
Unlike sets, lists typically allow duplicate elements.
-3，提供ListIterator来实现元素迭代。ListIterator继承自Iterator接口，并提供一些扩展方法。
The <tt>List</tt> interface provides a special iterator, called a* <tt>ListIterator</tt>, that allows element insertion and replacement, and* bidirectional access in addition to the normal operations that the* <tt>Iterator</tt> interface provides.
-4，提供一些其他扩展操作方法。
7，ArrayList源码。
-1，ArrayList是List的可变数组实现方式。实现了所有List接口的方法，大致同Vector类，只不过此类是不同步的。
size isEmpty get set iterator listIterator操作都以固定时间运行。即，添加n个元素需要O(n)事件运行，其他的操作也以线性时间运行。
每个ArrayList都存在一个capacity的实例，该实例用来存储List对应数组的长度。
在添加大数据操作时候，可以使用ensureCapacity操作来提前扩展大小。此操作是非线程安全的，如果多个线程同时访问一个ArrayList实例，而至少有一个线程从结构上（增加或者删除元素，或修改底层数组大小，不包含元素值的修改）修改了列表，那么它必须保持外部同步。一般通过封装该列表的对象进行同步操作来完成，如果不存该对象，可以使用Collections.synchronizedList方法包装列表实现。
List list = Collections.synchronizedList(new ArrayList(...));
使用迭代器遍历元素的时候，在创建迭代器之后，除非通过迭代器自身的remove或add方法从结构上对列表进行修改，否则在任何时间以任何方式修改都会抛出异常。
以上均为API对ArrayList的描述。我们可以使用代码对以上内容进行测试：
a. 测试 size isEmpty get set iterator listIterator add方法时间。
public class TestAdd {public static void main(String[] args) {long startTime = System.currentTimeMillis();List<Integer> lists = new ArrayList<Integer>();//测试add方法for(int i = 0 ; i < 1000000; i++){lists.add(1);}long endTime = System.currentTimeMillis();System.out.println("add添加1000000元素，用时： " + (endTime - startTime));//输出32//add 一个元素的时间startTime = System.currentTimeMillis();lists.add(2);endTime = System.currentTimeMillis();System.out.println("add添加1元素，用时： " + (endTime - startTime));//输出0//get 一个元素startTime = System.currentTimeMillis();lists.get(2);endTime = System.currentTimeMillis();System.out.println("get元素，用时： " + (endTime - startTime));//输出0}}
b. 使用capacity元素完成初始化操作：
long startTime = System.currentTimeMillis();List<Integer> lists = new ArrayList<Integer>(1000000);//测试add方法for(int i = 0 ; i < 1000000; i++){lists.add(1);}long endTime = System.currentTimeMillis();System.out.println("add添加1000000元素，用时： " + (endTime - startTime));//输出12
c.使用迭代器遍历ArrayList
startTime = System.currentTimeMillis();Iterator<Integer> iter = lists.iterator();int a ;while(iter.hasNext()){a = iter.next();}endTime = System.currentTimeMillis();System.out.println("迭代器元素，用时： " + (endTime - startTime));//输出33
-2，成员变量：
elementData： 数组，用来存储ArrayList对应的元素列表。使用capacity来存储数组长度。
private transient Object[] elementData;
size：ArrayList存储元素的长度。
modCount：此变量属于父类AbstractList。该元素记录了从结构上修改次列表的次数。此字段由iterator和listIterator方法返回的迭代器和列表迭代器实现。
-3，构造函数：
public ArrayList(int initCapacity)：如果初始化参数小于0则抛出异常，否则初始化列表中的数组。
public ArrayList(int initialCapacity) {super();if (initialCapacity < 0)throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);this.elementData = new Object[initialCapacity];}
public ArrayList()：初始化一个长度为10的数组。
public ArrayList() {this(10);}
public ArrayList(Collection<? extends e> c)：构建一个包含c中所有元素的列表，元素顺序按照Iterator返回的顺序排列。
public ArrayList(Collection<? extends E> c) {elementData = c.toArray();//转为数组size = elementData.length;// c.toArray might (incorrectly) not return Object[] (see 6260652)if (elementData.getClass() != Object[].class)//如注释c.toArray可能返回非数组对象，所以此处需要判断，确保返回的为数组对象elementData = Arrays.copyOf(elementData, size, Object[].class);}
使用到了Arrays.copyOf方法，我们可以进一步查看该方法：
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {T[] copy = ((Object)newType == (Object)Object[].class)? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;}
查看System.arraycopy源码：
public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);
-4，方法：
add(E e)：添加对应元素到数组中。add方法记调用了ensureCapacity方法，保证数组元素不越界，然后对数组元素的末尾增加了当前元素。
public boolean add(E e) {ensureCapacity(size + 1); // Increments modCount!!elementData[size++] = e;return true;}
ensureCapacity(int minCapacity):该方法判断数组元素是否已经超过了当前ArrayList中的数组长度，如果超过则增加长度。
public void ensureCapacity(int minCapacity) {modCount++;int oldCapacity = elementData.length;if (minCapacity > oldCapacity) {Object oldData[] = elementData;int newCapacity = (oldCapacity * 3)/2 + 1;if (newCapacity < minCapacity)newCapacity = minCapacity;// minCapacity is usually close to size, so this is a win:elementData = Arrays.copyOf(elementData, newCapacity);}}
add(int index, E element)：在数组固定位置添加元素。
remove(int index)：移除制定索引的元素。
public E remove(int index) {RangeCheck(index);//确保索引位置未超出最大size，超出则抛出异常。modCount++;//记录表结构修改计数器E oldValue = (E) elementData[index];int numMoved = size - index - 1;if (numMoved > 0)System.arraycopy(elementData, index+1, elementData, index,numMoved);//将后续元素均向前移动一位elementData[--size] = null; // Let gc do its workreturn oldValue;}
get(int index)：获取制定索引元素
public E get(int index) {RangeCheck(index);return (E) elementData[index];}
set(int index, E e)：更换制定索引元素值，使用e替换，并返回原有值。
ArrayList的操作基本都很简单，包括源代码，相对来说还是比较简单。看此处的代码的时候，建议先学习数据结构的线性表后，再来看次部分的代码。