属性：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

	// 数组默认长度
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    // 对于空实例对象来说，都是共享的
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    // 空实例对象默认共享的实例的数组。
    // 用来区分每个空实例指向的数组位置在第一次添加元素进来的时候
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */ 
    // 真正存储数据的数组。前面是transient关键字表示的不可以进行序列化
    transient Object[] elementData; // non-private to simplify nested class access

    // 数组中元素的个数
    private int size;
    
    

直接构造方法：

第一种就是直接指定数组的大小：

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

第二种就是默认不指定：

public ArrayList() {
    	// 在不指定数组容量大小的时候，使用的是这个数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

第三种就是转换方法：

    public ArrayList(Collection<? extends E> c) {
        // 将每个元素转换成
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            // 如果直接是ArrayList，那么就可以直接进行转换了
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                // 如果不是，可能是set、linkedList等，转换成Object类型的
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            // 如果为0，就可以使用这个
            elementData = EMPTY_ELEMENTDATA;
        }
    }

那么接着看下这里的toArray方法：

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

除了第三种构造方法不做说明，介绍下第一种构造和第二种构造的区别，如果指定了容量(>0)，那么首先会创建好一个数组；而没有指定的，就会直接指向一个空数组。但是如果容量为0和使用无参构造，这个时候也是有点区别的。最大的区别就是在于两个集合实例使用的数组不同。

直接看重要方法：

    public boolean add(E e) {
        // 确保容量是否足够
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

第一步做的事情就是先去检查容量是否足够放进去一个新的元素；

两种情况：如果足够，那么放入进去即可；如果不够，那么需要先来进行扩容；看下具体代码：

    private void ensureCapacityInternal(int minCapacity) {
        // 又继续调了两层。首先看calculateCapacity方法(计算容量)
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

calculateCapacity方法源码如下所示：

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 从前面的介绍中，可以看到这个是无参构造方法空实例的数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 数组默认大小和第size+1个元素是否能够放进去
            // 这里就是说，加入的元素的个数和数组默认大小10比较，取出来最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 如果elementData不是指向这个地址，那么就只有一种情况，走有参构造方法
        // 初始化容量是0或者是大于0
        return minCapacity;
    }

再回到刚刚调用这个方法的地方，继续执行，走ensureExplicitCapacity方法：

    private void ensureExplicitCapacity(int minCapacity) {
        // 隐藏在父类中的属性，表示的是数组中的元素修改的次数
        modCount++;

        // 可能会移除的代码块
        // 如果添加进来的元素的个数已经可以将其放满了，那么就需要扩容
        // 如果小于或者是等于，那么就先不扩容。
        // 至于等于的情况，就是说数组长度可能是10，当前已经放了九个元素了，然后第十个元素需要放置进来
        // 的时候，发现是等于10的，这里会等于0.因为还会剩下一个位置，所以可以继续放进去。
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

可以看下grow代码：

    private void grow(int minCapacity) {
        // 可能会溢出的代码
        // 首先计算出当前的数组的容量
        int oldCapacity = elementData.length;
        // 从这里可以看到扩容的倍数是1.5
        // 但是第一次扩的时候，如果elementData.length为0的话，那么这里相当于是没有进行扩容的
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 这里会做一步赋值。也就是说扩容之后，新的比原来的还小，那么将原来的。对应的是就是上面的
        // 如果初始条件下为0的时候
        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);
    }