ArrayList的add（E e）源码分析

成员变量

private static final int DEFAULT_CAPACITY = 10;//数组初始化长度为10
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  //初始化指向地址
transient Object[] elementData; // non-private to simplify nested class access
private int size;   //存储的元素个数，size<DEFAULT_CAPACITY

构造方法

/**
* 无参构造方法,默认空数组
*/
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 指定数组容量大小的构造方法
*/
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(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

插入第一个元素过程

add()方法

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 判断并扩容，第一次加入，size==0
        elementData[size++] = e;
        return true;
    }

/**
* ensureCapacityInternal方法
*/
private void ensureCapacityInternal(int minCapacity) {//minCapacity=1
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* calculateCapacity方法
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //第一次添加元素，elementData为空，成立
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { 
        return Math.max(DEFAULT_CAPACITY, minCapacity);	//DEFAULT_CAPACITY为10，返回10
    }
    return minCapacity;
}

/**
* ensureExplicitCapacity方法
*/
private void ensureExplicitCapacity(int minCapacity) {//minCapacity等于10
    modCount++;

    if (minCapacity - elementData.length > 0)//数组为空，成立
        grow(minCapacity);
}
/**
* grow方法
*/
private void grow(int minCapacity) {//传入10
 
    int oldCapacity = elementData.length;//数组为空长度为0
    int newCapacity = oldCapacity + (oldCapacity >> 1);//仍然为0
    if (newCapacity - minCapacity < 0)  //成立
        newCapacity = minCapacity;//把10 赋值给新容量
    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);//开辟一个新数组，长度为10
}

插入第一个元素的时候，开辟了一个长度为10的数组。属于延迟加载，添加元素时才分配空间10

array.copyOf方法的使用在另一个文章中

插入第n个元素，1<n<=10

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 参数为n 
    elementData[size++] = e;
    return true;
}

/**
* ensureCapacityInternal方法
*/
private void ensureCapacityInternal(int minCapacity) {//参数为 n 
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* calculateCapacity方法
* 不是第一次插入，elementData = 10
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //不是第一次加入，不成立
        return Math.max(DEFAULT_CAPACITY, minCapacity);	
    }
    return minCapacity;//返回n
}

/**
* ensureExplicitCapacity方法
*/
private void ensureExplicitCapacity(int minCapacity) {//minCapacity等于 n
    modCount++;

    if (minCapacity - elementData.length > 0)//n - 10 <0 所以不成立，不扩容
        grow(minCapacity);
}

插入第11个元素

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 传入11
    elementData[size++] = e;
    return true;
}

/**
* ensureCapacityInternal方法
*/
private void ensureCapacityInternal(int minCapacity) {//参数为 11
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* calculateCapacity方法
* 不是第一次插入，elementData = 10
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //不是第一次加入，不成立
        return Math.max(DEFAULT_CAPACITY, minCapacity);	
    }
    return minCapacity;//返回 11
}

/**
* ensureExplicitCapacity方法
*/
private void ensureExplicitCapacity(int minCapacity) {//minCapacity等于 11
    modCount++;

    if (minCapacity - elementData.length > 0)//11 - 10 >0 
        grow(minCapacity);//进行扩容
}
/**
* grow方法
*/
private void grow(int minCapacity) {//传入11
 
    int oldCapacity = elementData.length;//数组长度为 10
    int newCapacity = oldCapacity + (oldCapacity >> 1);//值为 15
    if (newCapacity - minCapacity < 0)  //不成立
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)  //数组太大，异常处理，无视
        newCapacity = hugeCapacity(minCapacity);
    //开辟一个新数组，长度为15，复制源数据
    elementData = Arrays.copyOf(elementData, newCapacity);
}

参考博客，有需要改进的可以留言