1、成员变量

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;

    private static final Object[] EMPTY_ELEMENTDATA = {};

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    transient Object[] elementData; 

    private int size;
	
    // ....
}

• serialVersionUID：序列化用的，暂时不清楚
• DEFAULT_CAPACITY：默认容量为10
• EMPTY_ELEMENTDATA：空数组，有参构造函数为0时用的
• DEFAULTCAPACITY_EMPTY_ELEMENTDATA：空数组，无参构造函数用的
• elementData：ArrayList集合存放元素的位置
• size：集合中元素占据的大小，注意不是elementData.legnth

2、构造方法

2.1、无参构造

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

方法说明：将elementData设置为空数组

2.2、有参构造1

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

参数说明：

initialCapacity：arraylist容量初始值

方法说明：

如果初始值大于0，将elementData设置为一个该长度的数组

如果为0，也是将elementData设置为空数组

如果小于0抛出异常

2.3、有参构造2

public ArrayList(Collection<? extends E> c) {
    this.elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

参数说明：

Collection<? extends E> c： E类型下的Collection的实现类集合

方法说明：

如果该集合中元素不是Object[] 集合就转化为Object[]集合

3、自动扩容

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = 
            ArraysSupport.newLength(oldCapacity,
                                    minCapacity - oldCapacity,
                                    oldCapacity >> 1          
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[
            Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

private Object[] grow() {
    return grow(size + 1);
}

ArrayList的扩容机制：

1. 执行add方法
2. 如果size == elementData.length 会触发扩容机制，执行grow()
3. 执行grow(size + 1)
   • 第2行：首先拿到原来的容量
   • 第3行：如果不是第一次添加
     • 设置新的容量为原来的1.5倍，并且将复制数组到新数组里面
   • 第9行：如果是第一次添加
     • 执行初始扩容，将elementData设置为初始值

4、增删改查

4.1、add

public boolean add(E e) {	// 向最后添加元素
    modCount++;					
    add(e, elementData, size);	// 调用下面方法
    return true;
}

private void add(E e, Object[] elementData, int s){ // 检查是否要扩容
    if (s == elementData.length)	
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

public void add(int index, E element) {	// 向指定位置添加元素
    rangeCheckForAdd(index);	
    modCount++;
    final int s;
    Object[] elementData;
    if ((s = size) == (elementData = this.elementData).length) {
        //扩容
        elementData = grow();
    }
    
    System.arraycopy(elementData, index,
                     elementData, index + 1,
                     s - index);	
    elementData[index] = element;
    size = s + 1;
}

4.2、remove

public E remove(int index) {	// 指定位置删除元素
    // 检查索引是否不在范围
    Objects.checkIndex(index, size);
    
    // 新的指针指向elementData
    final Object[] es = elementData;
    @SuppressWarnings("unchecked") 
    E oldValue = (E) es[index];
    // 进行删除操作
    fastRemove(es, index);
	// 返回删除的元素
    return oldValue;
}

private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize = size - 1;	// newSize 原来size - 1 
    if (newSize > i)				// 如果删除的不是最后一个元素
        System.arraycopy(es, i + 1, es, i, newSize - i);
    size = newSize;
    // 这里不管删除的是不是最后一个元素，都将原数组最后一个置为null
    // 如果是删除的最后一个, 上一个if不执行，提高效率
    es[size] = null;	
}

4.3、set

将指定索引的元素改为新的值， 返回老的值

public E set(int index, E element) {
    Objects.checkIndex(index, size);
    checkForComodification();
    E oldValue = root.elementData(offset + index);
    root.elementData[offset + index] = element;
    return oldValue;
}

4.4、get

得到索引为index的元素

public E get(int index) {
    Objects.checkIndex(index, size);
    return elementData(index);
}

5、总结

1. ArrayList底层实现是数组。
2. 当使用无参数构造函数创建ArrayList对象时，ArrayList对象中的数组初始长度为0（是一个空数组）。
3. ArrayList的扩容策略是每次都增加当前数组长度的一半（非固定分配）。
4. ArrayList的扩容方式是直接创建一个新的数组，并将数据拷贝到新数组中。