ArrayList源码解析

ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。

ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。
构造方法

    public ArrayList(int initialCapacity) {
        // 传入的初始容量大于0，则会创建指定容量长度的数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
        // 如果传入的初始容量为0，则指定为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
        //如果容量小于0，属于非法参数，直接抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    // ArrayList无参构造函数
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    // 创建一个包含collection的ArrayList
    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 {
            // 替换为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

增加元素
在增加元素之前一般会先判断是否需要扩容，如果满了就要进行扩容了。

    //将指定的元素追加到此列表的末尾。
    public boolean add(E e) {
    //判断是否扩容
        ensureCapacityInternal(size + 1);  
        elementData[size++] = e;
        return true;
    }

    public void add(int index, E element) {
    //判断元素要插入的位置是否越界
        rangeCheckForAdd(index);
        //判断是否扩容
        ensureCapacityInternal(size + 1);  
        //将元素从最后一个开始每个元素往后移一位一直到index位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        //将元素插入指定位置
        elementData[index] = element;
        //元素个数加一
        size++;
    }

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

数组扩容

private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果数组为空数组，那么就取minCapacity和默认容量10的较大值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    private void ensureExplicitCapacity(int minCapacity) {
    // 记录数组的修改次数
        modCount++;
        // 是否minCapacity超过当前数组的长度
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //数组扩容，每次扩容是前一次的1.5倍
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新数组为原数组的1.5倍
        // 判断计算后的新数组容量是否满足要求的最小容量
        // 如果不满足，则直接将新数组的容量设置为需要的容量
        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);
    }

删除元素
分两种一种是指定元素一种是指定元素下标。

//通过下标删除元素
public E remove(int index) {
        //判断元素是否越界
        rangeCheck(index);
        
        modCount++;
        // 从数组中返回下标为index的元素
        E oldValue = elementData(index);

        //如果移除的元素不是最后一位则要对数组index之后的元素进行移位
        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
        return oldValue;
    }

//判断数组是否越界
private void rangeCheck(int index) {
    if (index >= size) {
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
}
 
// 返回数组中下标为index的元素
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

//通过指定元素来删除
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;
    }

private void fastRemove(int index) {
    modCount++;
 
    // 判断需要移动的元素数量
    int numMoved = size - index - 1;
 
    // 如果删除的不是最后一个元素
    // 则将index后面的元素一次往前移动
    if (numMoved > 0) {
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    }
 
    // 将数组空出的最后一个位置置位null，然后数组元素减1
    elementData[--size] = null; // clear to let GC do its work
}

数组缩容
可以思考这种场景，一个ArrayList，刚开始初始容量为0，添加元素后，容量增大，但是后期数组元素在不断的删除元素，虽然数组中只剩下了5个元素，但是数组的长度还是数组中元素到达最大值的时候，这是极大地浪费，此时需要进行缩容，就是让底层数组调整为适合长度，最适合的长度就是刚好和元素数量个数相同。
　　ArrayList提供了trimToSize方法，就是进行缩容操作，将底层数组设置为刚好装下现有元素的长度。

public void trimToSize() {
    modCount++;
 
    // 如果数组中的元素数量小于数组的长度，才进行缩容
    // 如果数组中没有元素，则将底层数组切换为一个空数组，否则就换为size大小的数组
    if (size < elementData.length) {
        elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

查找数组元素

public E get(int index) {
    // 数组越界检测
    rangeCheck(index);
 
    // 返回index下标的元素
    return elementData(index);
}
 
// 判断数组是否越界
private void rangeCheck(int index) {
    if (index >= size) {
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
}
 
// 返回数组中下标为index的元素
@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}