注：这里使用java 1.6版本
1.ArrayList继承AbstractList，实现List、RandomAccess、Cloneable、Serializable接口；
2.ArrayList的内部，通过数组实现。
如下：
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer.
*/
private transient Object[] elementData;在ArrayList中，虽然是泛型的，但是实现的时候，使用的是Object数组；原因应该是java目前不支持泛型数组。
HashMap内部也是通过数据实现的，其容量（capacity）也正好是数组的长度；不同的是，HashMap的实现是Entry数组）
3.ArrayList的初始化方法
ArrayList有3中初始化方法：
Public ArrayList(int initialCapacity);
这是基本的初始化方法，代码如下：
/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @exception IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}这里super()方法是一个空的方法；
然后是参数校验；
最后初始化数组对象，完成整个初始化方法。
Public ArrayLIst();
调用了第一个初始化，默认的容量是10；
Public ArrayList(Collection<? Extends E> c);
这是使用已有的集合类进行初始化，代码如下：
/**
* Constructs a list containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
*
* @param c the collection whose elements are to be placed into this list
* @throws NullPointerException if the specified collection is null
*/
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)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}正常情况下，将原有集合中的元素拷贝到elementData数组中即可，然后设置元素的个数；对于某些情况，c.toArray()方法，可能不能返回一个Object数组，所以最后进行了一次类型检查——当类型不匹配的时候，需要执行copyof方法，将类型进行一次转换。
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;
}需要注意的是，这里申请了新的内存空间。
4.trimToSize
减少ArrayList的长度为size；
ArrayList的容量应是内部数组elementData的长度，这里使用实际元素的数量size进行一次裁剪。在保证内容的前提下，减少ArrayList的容量。
实现的方式是使用前面提到的copyOf方法，这里重新申请了内存空间，将元素拷贝之后，原来的数组将会被回收。但是存在一定的开销。
同时，使用这个方法的时候，最好能够保证后续不再会向ArrayList中写入数据了，否则数组扩容，也要有一定的开销。
慎用。
5.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);
}
}ArrayList的扩容，通过ensureCapacity方法实现；参数是新的容量大小。
扩容通过两步执行，先扩容1.5倍；如果新的容量还是小于参数值，那么直接将容量设置为参数值大小。所以，有可能出现执行该方法之后，新的ArrayList的容量和设置的参数值不同的情况。
具体的执行还是通过Arrays的copyof方法进行，末尾通过null进行补全。
6.indexOf和lastIndexOf
判断一个元素是否存在在ArrayList当中；
indexOf找到该元素的第一个位置，lastIndexOf找到该元素的最后一个位置；如果找到了，则返回该元素的位置；如果没有找到，则返回-1。
indexOf的代码如下：
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}在indexOf方法中，使用循环进行查找；所以如果数组的容量很大，在最坏的情况下（参数元素不在ArrayList中），需要遍历完所有的元素，这个性能开销还是比较大的。
这里对于null和非null元素进行了分开判断；对于null元素的查找，直接使用“==”进行判断，对于非null元素，使用“equals方法”。这样在执行效率上略有区别。
lastIndexOf方法和indexOf方法基本上是一样的。不同的地方在于，indexOf的遍历，从头部开始，而lastIndexOf方法的遍历，从尾部开始。所以这里就不贴出lastIndexOf方法的代码了。
另外，在ArrayList中，contains方法也是通过indexOf方法实现的。只需要判断结果是不是-1即可。
7.clone
ArrayList实现了cloneable接口，其clone()方法的实现如下：
public Object clone() {
try {
ArrayList<E> v = (ArrayList<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}这里还是同Arrays的copyOf方法实现的；不过没看明白，怎么没有设置新的ArrayList的size参数。写了测试代码，发现clone之后的ArrayList，size的参数是进行了设置的；没看懂是在clone的那一步执行的……
8.toArray
ArrayList的toArray方法，返回数组形式的元素；
这里通过Arrays.copyOf方法进行实现，所以这里的返回结果还是新的对象，改动不会变更原有的ArrayList的结果。
还有一种toArray的实现：
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}这里是将ArrayList的元素写入指定的数组a中。
默认的toArray方法，返回的是Object数据；而带参数的toArray方法，返回的类型是T或者T的子类，类型是有保证的。同时，带参数的toArray方法，一般情况下，返回的数组就是参数a的数组，但是当a的长度小于size时，就会是一个新的数组。此时，新数组的创建是有额外的开销的，使用的时候需要特别注意。
在ArrayList中，对于元素的拷贝有多处使用。
9.get方法
ArrayList的get方法如下：
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}首先使用RangeCheck方法，检查数组是否越界；
如果越界，则抛异常出来；正常情况下，返回对应的结果。这里对于返回的结果进行了强制类型转换。
private void RangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
}10.set方法
set方法将元素写入到ArrayList中。
public E set(int index, E element) {
RangeCheck(index);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}首先，还是进行类型检查；正常后，保存旧值，写入新值；最后，返回旧值。
相对来说比较简单的操作。
11.add方法
add方法像ArrayList中插入新的元素，元素写到末尾。
public boolean add(E e) {
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}这里先是进行容量检查，如有必要，进行扩容处理；
然后将正确的结果写入数组的末尾，size增加1。
这里，进行容量检查的时候，modCount会加1，无论最后是否进行了扩容。
还有一种带参数的add方法，将元素E，写入指定的位置。
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);
ensureCapacity(size+1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}还是先进行数据越界检查；容量检查；然后从index位置开始，将所有元素的位置向后移一位；最后把新的元素插入到index的位置。
12.remove方法
ArrayList提供了两种remove方法，一种是remove某个位置的元素，另外一种是删除元素E。
public E remove(int index) {
RangeCheck(index);
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 work
return oldValue;
}流程如下：
数组越界检查；
modCount自增；
获取要删除的位置上的元素；
通过移位操作，将从该位置开始的元素，向前移动1位；
设置最后的数组元素为null，其值将被gc回收。
最后返回已删除的元素。
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;
}这里基于元素的删除，是将首次出现的该元素进行删除；如果该元素出现在ArrayList中，则进行删除；否则，返回false。
这里先进行元素的查找，和contains方法中的一致；
查找到对应的元素之后，使用fastRemove方法进行删除。这里的fastRemove方法就是移位删除，和前面的基于位置的删除是一样的。
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; // Let gc do its work
}13.clear方法
将ArrayList中的所有数组中的元素设置为null；size清零。同时modCount加一，ArrayList总的数组长度不变。
public void clear() {
modCount++;
// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}14.addAll方法
ArrayList提供两种添加集合的方法。
先看第一种：
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}这个方法和add方法基本类似。
第二种，将集合元素加入ArrayList的某个位置。
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}这里将数据形式的集合元素，插入从index元素开始的位置。
流程如下：
检查参数index，保证其大于0，小于size；
获取集合元素的数组形式；
容量检查；
将从index位置开始的ArrayList元素，向后移动；
将集合元素插入到ArrayList中，通过system的arraycopy完成。
Size完成变更；
返回。
这个返回结果，有点莫名其妙……
15.removeRange
删除ArrayList中，某个范围内的元素。
如下：
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// Let gc do its work
int newSize = size - (toIndex-fromIndex);
while (size != newSize)
elementData[--size] = null;
}还是通过system的arraycopy完成；将末尾的元素全部设置为null。
这里没有对from和to进行检查。不过，这是个protected的方法，不公开访问。
16.最后，ArrayList为了满足序列化的要求，实现了writeObject和readObject的方法。
相对来说，ArrayList比HashMap稍微简单一些。
