此源码分析JDK版本为1.7，只是简单分析，算是个人看源码的一点小总结，随意性比较强，专业的还需百度。
先简单介绍一下ArrayList，ArrayList为线性数据结构，时间复杂度为O(1)，内部存储为数组。以下所有表达ArrayList的内容统称为数组。
ps:ArrayList和Vector的区别就是ArrayList是线程不安全的，Vector是线程安全的。Vector底层核心方法都为synchronized。

简介

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

属性

//默认数组大小
private static final int DEFAULT_CAPACITY = 10;
//默认空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//数组(ArrayList中的数据就放在此数组中)
private transient Object[] elementData;
//数组真实数据的长度(与数组的长度不一样)
private int size;
//数组最大大小常量(Integer.MAX_VALUE - 8原因是尝试分配较大的数组可能会导致OutOfMemoryError)
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//修改次数(对于线程安全至关重要，在Iterator中会解释)
protected transient int modCount = 0;

构造方法

//无初始化长度的构造方法
public ArrayList() {
    super();
    //将属性中的空数组赋给elementData
    this.elementData = EMPTY_ELEMENTDATA;
}
//初始化长度的构造方法
public ArrayList(int initialCapacity) {
    super();
    //当初始化长度小于0则抛出异常
    if (initialCapacity < 0)
    throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    //new该长度的Object数组给与elementData
    this.elementData = new Object[initialCapacity];
}
//根据父类Collection类型的对象进行构造的构造方法
public ArrayList(Collection<? extends E> c) {
    //不同的Collection的实现类会有不同的实现，但最终结果都是转为Object数组
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
    //目前未知(属性定义为Object，判断不等于因此觉得不太理解，而且debug各种类型都是直接跳过此方法，暂时觉得此判断不会进入)
    elementData = Arrays.copyOf(elementData, size, Object[].class);
}

方法

//返回数组大小
public int size() {
    return size;
}
//是否为空
public boolean isEmpty() {
    return size == 0;
}
//获取该值的下标(无返回-1)
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++)
            //可能会有人说Object默认的equals()实现是==，觉得此方法块没意义，但实际调用的为真实类型的equals()方法
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}
//获取最后该值的下标(无返回-1)
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            //同上
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}
//是否包含
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
//返回数组(并不是返回Object数组，而是真实类型的数组)
public Object[] toArray() {
    //查看copyOf源码会发现返回的是真实类型数组
    return Arrays.copyOf(elementData, size);
}
//当调用get()时会通过此方法返回值 (default，外部无法调用)
E elementData(int index) {
    return (E) elementData[index];
}
//检查传入的下标参数是否越界
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//返回该下标所对应的值
public E get(int index) {
    //检查下标参数是否越界
    rangeCheck(index);

    //根据下标返回值
    return elementData(index);
}
//设置下标和值
public E set(int index, E element) {
    //检查下标参数是否越界
    rangeCheck(index);

    //获取该下标的值
    E oldValue = elementData(index);
    //为该下标赋新值
    elementData[index] = element;
    //返回旧值
    return oldValue;
}
//扩容：第一步将传入的值与默认最小值进行对比
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);
}
//扩容：扩容真正实现(默认情况下扩容之后的大小为当前数组长度+数组对2取余)
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //定义变量为当前大小加一半取余
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果变量小于传的参数，则新的数组大小为传入的参数
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //如果变量大于数组默认最大值则调用hugeCapacity()方法返回值
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //将新的数组大小与默认最大值进行对比
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    //调用Arrays.copyOf()扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}
tag:第一个判断:如果传入的值小于[数组大小加对二取余]则新的数组大小为传入的值，定义的新值为传入的值；如果不是则无操作。第二个判断:第一步运算厚的结果如果大于默认数组最大长度，则返回hugeCapacity()计算后的值；如果不是则无操作
//判断传的值是否大于默认数组最大长度，如果是则为Integer最大值；如果不是则为默认数组最大长度，返回可用大小
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}
//在数组中增加值
public boolean add(E e) {
    //添加则会增加modCount
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
//为某个下标新增值
public void add(int index, E element) {
    //判断下标是否越界
    rangeCheckForAdd(index);

    //先扩容(防止index刚好为当前数组长度)
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //将源数组index位置开始的数组复制到目标数组index+1后，复制的数量为size-index个
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}
//删除某下标对应的值
public E remove(int index) {
    //判断下标是否越界
    rangeCheck(index);

    //增加修改次数
    modCount++;
    //获取旧值
    E oldValue = elementData(index);

    //判断删除该下标元素需要向前移动多少个位置
    int numMoved = size - index - 1;
    //如果当前下标不是最后一个元素，则将源数组index+1位置开始的数组复制到目标数组index后，复制的数量为numMoved个
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work  //置空原尾部数据 不再强引用， 可以GC掉

    return oldValue;
}
//根据下标删除值(不检查下标是否越界)
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  //置空原尾部数据 不再强引用， 可以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;
}
//清空数组
public void clear() {
    //增加修改次数
    modCount++;

    // clear to let GC do its work  //置空原尾部数据 不再强引用， 可以GC掉
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    //数组真实长度归零
    size = 0;
}
//将Collection增加到当前数组之后
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    //扩容大小为当前数组长度加参数数组长度
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    //设置真实数组大小长度
    size += numNew;
    return numNew != 0;
}
//判断增加下标是否越界(与判断是否越界区别在于少了=size和增加了不小于0)
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//在下标后增加Collection
public boolean addAll(int index, Collection<? extends E> c) {
    //判断增加下标是否越界
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    //扩容大小为当前数组长度加参数数组长度
    ensureCapacityInternal(size + numNew);  // Increments modCount

    //位移量
    int numMoved = size - index;
    if (numMoved > 0)
        //将index之后的位移量numNoved空置出来
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);
    //将Collection的数组放置index之后index + numNew之前
    System.arraycopy(a, 0, elementData, index, numNew);
    //设置真实数组大小长度
    size += numNew;
    return numNew != 0;
}
//删除指定区间内的数组内容(protected修饰，subList方法会调用，外部不可访问)
protected void removeRange(int fromIndex, int toIndex) {
    //增加修改次数
    modCount++;
    //计算位移量
    int numMoved = size - toIndex;
    //将toIndex后的数组放置fromIndex之后
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
                     numMoved);

    // clear to let GC do its work
    //计算应当删除的起始下标
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }
    //设置真实数组大小长度
    size = newSize;
}
//与Collection取交集
public boolean retainAll(Collection<?> c) {
    //实际调用，true表示取交集
    return batchRemove(c, true);
}
//根据complement决定取交集还是取非交集(注意this.elementDat和elementData )
private boolean batchRemove(Collection<?> c, boolean complement) {
    //定义变量
    final Object[] elementData = this.elementData;
    //为了方便理解可以理解为:r为this.elementData的下标，w为elementData 下标
    int r = 0, w = 0;
    //定义是否修改成功
    boolean modified = false;
    try {
        for (; r < size; r++)
            //根据complement决定是否将此值放入elementData中
            if (c.contains(elementData[r]) == complement)
                //w++是将值放入下标为w之后w再+1
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        //如果c.contains()抛出异常是则r一定不等于size，则执行下方。将this.elementData下标r之后的复制到elementData下标w之后
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        //如果w!=size则需要将w之后的数组清楚
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
                modCount += size - w;
                size = w;
                //只有进入此代码块才表明修改成功
                modified = true;
        }
    }
    return modified;
}
//返回Itr迭代器
public Iterator<E> iterator() {
    return new Itr();
}
//返回ListItr迭代器
public ListIterator<E> listIterator() {
    return new ListItr(0);
}
//subList部分放置在ArrayList-SubList文章中
tag:在上段代码中，只有w!=size的情况下才会表明修改成功。我的理解：首先，contains()发生异常只会是空指针。如果相等则可能发生以下几种情况1.求交集但两个数组完全一样2.求非交集两个数组完全不一样3.从开始就出现异常

总结

1.ArrayList增删实现基本靠System.arraycopy()实现，修改是通过数组下标(只能在下标范围内修改)
2.通过modCount解决线程安全问题(iterator遍历时如果修改则会直接抛出异常)
3.手动置null去除强引用使gc下次工作是回收此对象
4.增、删都会因为数组扩容二影响效率，修改和查询不会影响效率
5.增、删都会修改modCount，修改和查询不会修改modCount
6.手动置null只是将内存地址取消引用，因为gc是通过计数法来进行回收，当内存地址没有被引用就会被回收

ArrayList源码分析

ArrayList源码分析

简介

属性

构造方法

方法

总结