java8集合——ArrayList

底层由 Object数组 实现

// transient关键字修饰的字段是不能够被序列化的
transient Object[] elementData; 

ArrayList 提供了三个构造器

// 指定数组容量的构造器
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;
    }
}

如果使用无参构造函数，默认是创建空数组。

ArrayList#get方法

// 因为底层是一个数组，可以根据指定的位置来查询，所以快
public E get(int index) {
    // 检查index是否在范围内
	rangeCheck(index);
	return elementData(index);
}

ArrayList#add方法

// 向ArrayList添加对象，数组会扩容，并在数组的最后加上该对象
public boolean add(E e) {
	// 确保数组的容量
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // size在向数组添加对象时自增1。
    elementData[size++] = e;
    return true;
}

// 方法中调用的ensureCapacityInternal主要用来调整容量
private void ensureCapacityInternal(int minCapacity) {
	// 如果数组是默认的空数组，取默认容量（10）和 minCapacity 的最大值
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
	// 修改的次数+1
	// 用于在 Iterator 遍历时确保ArrayList不能被修改，否则会抛异常
    modCount++;

    // 如果最小需要的容量大于当前数组的长度，需要扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
	// 当前数组容量
    int oldCapacity = elementData.length;
    // 新数组容量=当前数组容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 新数组容量和 minCapacity 取大的值
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 会创建一个新数组，且元素都拷贝到新数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

在添加元素前，确保数组的容量。如果是空数组，使用默认的容量 DEFAULT_CAPACITY ，默认容量为 10。如果最小需要的容量大于当前数组的长度，需要扩容，新容量为旧容量的1.5倍。

由源码可以发现，如果数组容量不够需要扩容（创建新数组），所以如果要在 ArrayList 添加大量元素，可以在初始化时指定容量，减少扩容操作提升性能。

ArrayList#remove方法

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;
    if (numMoved > 0)
    	// index后的元素向前移一位
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 数组最后的元素设置为null
    elementData[--size] = null; // clear to let GC do its work
}

删除元素时，循环遍历获取第一个和要删除元素相等的元素的索引，把改索引后的元素向前移动一个位置，数组最后的元素设置为null。

如果在forEach循环遍历时调用remove方法删除元素会报ConcurrentModificationException异常，因为forEach循环其实是Iterator的语法糖，Iterator遍历中有对集合最变更就会报ConcurrentModificationException异常。

如果在fori循环遍历时调用remove方法删除元素时，因为索引之后的元素向前移一位，导致有遗漏遍历的元素。

建议使用Iterator遍历并删除元素，在遍历过程中有改动集合，会报ConcurrentModificationException异常。

---

欢迎小伙伴们积极指正和讨论，一起共同成长。