java ArrayList 源码分析（1.8）

简介

ArrayList 跟HashMap一样是很常用的集合类。

特点

ArrayList 的底层使用的依然是数组，但是与 Java 中常规的数组不同的是，它的容量能动态增长。在添加大量元素前，java通过调用ensureCapacity操作来增加 ArrayList 实例的容量。

内部变量

// 默认容量为10
private static final int DEFAULT_CAPACITY = 10;

// 空对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};

// 默认空对象数组，由空的构造参数生成
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// ArrayList对象实际上就是一个容器数组
transient Object[] elementData; // non-private to simplify nested class access

// 实际元素大小
private int size;

// 最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

源码分析

构造函数

/**
 * 指定容量大小的构造函数
 */
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) {
        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);  // Increments modCount!!
        // 将新元素增加到末尾
        elementData[size++] = e;
        return true;
    }

接下来分析容量检测以及扩容的源码:

	private void ensureCapacityInternal(int minCapacity) {
		// 如果数组容器为空，初始化容器的容量，默认为10
        if (elementData == DEFAULTCAPACITY_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);
    }
	
	private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 通过位运算符扩容，容量在当前的基础上 + 50%
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

指定索引的 add 方法

public void add(int index, E element) {
    // 确保该索引要合法即大于等于0并且小于等于数组长度
    rangeCheckForAdd(index);

    // 确保数组容量大于等于size+1
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将index索引位置（包括）及之后的元素都向后挪动一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 将index索引处设置为新增元素
    elementData[index] = element;
    size++;
}

get方法

public E get(int index) {
    // 防止越界，索引不能大于数组长度
    rangeCheck(index);
    
    // 直接返回索引处的元素
    return elementData(index);
}

remove 方法

public E remove(int index) {
    // 防止越界，索引不能大于数组长度
    rangeCheck(index);

    // 操作数+1
    modCount++;
    E oldValue = elementData(index);

    // 将index后的元素都向前挪动一位，原index的元素就删除了
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 数组长度减1
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}