【集合类】源码解析之 ArrayList类

ArrayList

基于数组，线程不安全，随机存取，查询快增删慢，以1.5倍扩容，最大是Integer.MAX - 8

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{

重点字段

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

/**
* 用于有参构造函数初始化时，如果传入的容量为0则用其进行初始化数组 
* 1.7 如果是这种情况是new一个容量为0的数组，如果存在多个这种情况就会创建多个容量为0的数组
* 1.8做了一定优化使其指向一个实例
*/
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 用于无参构造函数初始化数组，与 EMPTY_ELEMENTDATA 的区别在于
 * DEFAULTCAPACITY_EMPTY_ELEMENTDATA在添加一个元素后以 DEFAULT_CAPACITY 进行扩容，扩容后 elementData.length=10
 * 而 EMPTY_ELEMENTDATA 扩容后 elementData.length=1
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 底层封装的数组，用于存储元素
transient Object[] elementData; // non-private to simplify nested class access

// 集合的大小（实际存储的元素数）
private int size;

构造函数

// 空参构造 初始化容量为 10 的空列表
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 构造具有指定容量的列表 如果容量为0则使用 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);
    }
}

// 构造一个包含指定集合元素的列表 如果集合容量为0则使用 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;
    }
}

对于空参构造函数使用的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空数组，但是为什么注释为-“初始化容量为 10 的空列表”？详见扩容

对于ArrayList(Collection<? extends E> c)为什么需要if (elementData.getClass() != Object[].class)判断然后进行转换？

这是因为jdk的一个bug(6260652)，toArray方法返回的不一定是Object[]类型的数组，导致在调用toArray后进行数组赋值会报错，所以构造函数中判断不是Object[].class就会进行转换，以下例子能够证明:

List<String> list = new ArrayList<>(Arrays.asList("java")); // 构造器做了转换
System.out.println(list.getClass()); // class java.util.ArrayList
Object[] objects = list.toArray();
System.out.println(objects.getClass()); // class [Ljava.lang.Object;
objects[0] = new Object();

List<String> list2 = Arrays.asList("java");
System.out.println(list2.getClass()); // class java.util.Arrays$ArrayList
Object[] objects1 = list2.toArray();
System.out.println(objects1.getClass()); // class [Ljava.lang.String;
objects1[0] = new Object(); // java.lang.ArrayStoreException: java.lang.Object

// 对于 ArrayList 的 toArray 返回的一定是Object[]
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

// 而对于 Arrays$ArrayList 的 toArray 返回的是泛型类型的数组，所以还是实际类型，这个时候将 Object 赋值给 String 就会报错
private final E[] a;
@Override
public Object[] toArray() {
    return a.clone();
}

扩容

// 增加数组的容量，确保能存储 minCapacity 个元素
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        : DEFAULT_CAPACITY;

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

如果是数组是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 实例。minExpand会被设置为10，如果此时minCapacity小于等于minExpand，则不马上进行扩容，而是在进行add操作时初始化一个容量为10的空数组，所以无参构造函数的注释才那么写

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

在add操作内存会调用 ensureCapacityInternal 私有方法来确保有足够的容量放置元素，其中 calculateCapacity 判断是否是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 实例，如果是的话并且 minCapacity 小于 DEFAULT_CAPACITY 则初始化一个容量为10的空数组，这其实是一个延迟初始化的技巧。

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // 如果需要扩容的大小大于原容量则调用扩容方法
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 允许分配的最大数组大小，一些 VM 会在数组头部储存头数据，试图尝试创建一个比 Integer.MAX_VALUE - 8 大的数组可能会产生 OOM 异常
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 按照原容量的1.5倍进行扩容
    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);
}

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

对于无参构造函数确实是构造了容量为10的数组，只是不是一开始就初始化，而是使用了延迟初始化的方式，在add的时候才进行初始化。对于空参构造使用 DEFAULTCAPACITY_EMPTY_ELEMENTDATA ，而 new ArrayList(0) 使用 EMPTY_ELEMENTDATA ,前者不知道需要的容量大小，后者预估的容量比较小，所以通过不同的空数组实例使用不同的扩容算法，对于无参构造：10 ->15->22…，有参且参数为0: 0->1->2-3->4->6->9…

存储

// 将指定的元素追加到此列表的末尾
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

// 在此列表中的指定位置插入指定的元素
public void add(int index, E element) {
    // 检查数组角标是否越界
    rangeCheckForAdd(index);
	// 扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 拷贝数组
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

// 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

// 将指定集合中的所有元素插入到此列表中，从指定的位置开始
public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        // 如果是向中间插入，先复制出足够容量的数组，再进行整体复制
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

System.arraycopy() 方法

src:源数组;

srcPos:源数组要复制的起始位置

dest:目的数组;

destPos:目的数组放置的起始位置

length:复制的长度

注意：src and dest都必须是同类型或者可以进行转换类型的数组．

有趣的是这个函数可以实现自己到自己复制

public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);

// 往指定角标 index 插入指定元素 element
int index = 1;
int element = 4;
int size = 3;

Integer[] elementData = new Integer[4];
elementData[0] = 1;
elementData[1] = 2;
elementData[2] = 3;
System.out.println(Arrays.toString(elementData)); // [1, 2, 3, null]

System.arraycopy(elementData, index, elementData, index + 1,
                 size - index); // [1, 2, 2, 3]

elementData[index] = element; 
System.out.println(Arrays.toString(elementData)); // [1, 4, 2, 3]

删除

// 删除该列表中指定位置的元素
public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(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;
}

// 从列表中删除指定元素的第一个出现（如果存在）
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)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

// 从列表中删除所有元素
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

// 从这个列表中删除所有索引在 fromIndex （含）和 toIndex （不含）之间的元素
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
                     numMoved);

    // clear to let GC do its work
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }
    size = newSize;
}

// 从此列表中删除指定集合中包含的所有元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

// 仅保留此列表中包含在指定集合中的元素
public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, true);
}

// 批量删除 complement=false 删除不包含的，=true 删除包含的
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    // r : 从0~size-1遍历元素每次循环递增 w : 遇到包含（complement=true）/不包含（complement=false）的元素就自增
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            // complement=false,c包含元素则用r角标的数据覆盖掉w角标的数据，并且r自增，w自增。否则r自增，w不动
            // complement=true,c不包含元素则用r角标的数据覆盖掉w角标的数据，并且r自增，w自增。否则r自增，w不动
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
        // 把需要移除的数据都替换掉，不需要移除的数据都前移
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        // 异常流，存在并发修改的情况
        if (r != size) {
            // 如果存在并发删除，则 size - r 为负数，System.arraycopy 会报 java.lang.ArrayIndexOutOfBoundsException
            // 如果存在并发添加，则将添加的元素追加到w索引后面
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        // w 是最后一个被替换的元素，其余元素都前移了，所以把index > w的都置null,然后修改modCount和size
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

removeAll例子理解

List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6);
List<Integer> otherList = Lists.newArrayList(2, 4, 6);
list.removeAll(otherList);

循环次数	r	w	if	elementData[w++] = elementData[r]	原数组	替换值	替换后
1	0	0	true	elementData[0] = elementData[0]	123456	1->1	123456
2	1	1	false
3	2	1	true	elementData[1] = elementData[2]	123456	3->2	133456
4	3	2	false
5	4	2	true	elementData[2] = elementData[4]	133456	5->3	135456
6	5	3	false

循环结束后 w == 3 从原数组的下标 3开始将下标大于3的的置空 modcount + 3 数组长度变为 3

序列化和反序列化

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);
	
    // 用的是size而不是elementData.length,说明只序列化实际存储的元素
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

Object[] elementData 用了 transient 修饰，代表序列化时忽略，但是他自身实现了序列化和反序列，那为什么还要用 transient 修饰呢？实际上，ArrayList 通过动态数组的技术，当数组放满后，自动扩容，但是扩容后的容量往往都是大于或者等于 ArrayList 所存元素的个数。如果直接序列化 elementData 数组，那么就会序列化一大部分没有元素的数组，导致浪费空间，为了保证在序列化的时候不会将这大部分没有元素的数组进行序列化，因此设置为 transient

jdk1.8新增的方法实现

// -> implement Iterator jdk1.8
@Override
public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

// -> implement Collection jdk1.8
@Override
public boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    int removeCount = 0;
    // BitSize使用一个Long(64位)的数组中的每一位是否为1来标识当前index的元素是否存在
    final BitSet removeSet = new BitSet(size);
    final int expectedModCount = modCount;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        @SuppressWarnings("unchecked")
        final E element = (E) elementData[i];
        // 将符合filter的元素下标设置到BitSet中，即BitSet中对应的下标设置为 1
        if (filter.test(element)) {
            removeSet.set(i);
            removeCount++;
        }
    }
    // 判断是否有并发修改
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }

    // 判断是否有元素需要删除
    final boolean anyToRemove = removeCount > 0;
    if (anyToRemove) {
        // 新数组大小
        final int newSize = size - removeCount;
        for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
            // 返回下一个清除位（0）的索引（从本身开始） 
            i = removeSet.nextClearBit(i);
            elementData[j] = elementData[i];
        }
        // 将多余的位置空
        for (int k=newSize; k < size; k++) {
            elementData[k] = null;  // Let gc do its work
        }
        this.size = newSize;
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

    return anyToRemove;
}

// -> implemenet List jdk1.8
@Override
@SuppressWarnings("unchecked")
public void replaceAll(UnaryOperator<E> operator) {
    Objects.requireNonNull(operator);
    final int expectedModCount = modCount;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        elementData[i] = operator.apply((E) elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

// -> implement List jdk1.8
@Override
@SuppressWarnings("unchecked")
public void sort(Comparator<? super E> c) {
    final int expectedModCount = modCount;
    Arrays.sort((E[]) elementData, 0, size, c);
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

// implement List, Collection jdk1.8
@Override
public Spliterator<E> spliterator() {
    return new ArrayListSpliterator<>(this, 0, -1, 0);
}

// jdk1.8
static final class ArrayListSpliterator<E> implements Spliterator<E> {
	...
}

BitSet

BitSet bit = new BitSet();
bit.set(2);
bit.set(4);
bit.set(6); // [0, 0, 1, 0, 1, 0, 1]  
System.out.println(Arrays.toString(bit.toLongArray())); // [84] = 4 + 16 + 64 = 84
for(int i = 0; i < 7; i++){
    int i1 = bit.nextClearBit(i); // 0 1 3 3 5 5 7
    // index = 0 时 bit[0] == 0	bit.nextClearBit == 0
	// index = 1 时 bit[1] == 0  bit.nextClearBit == 1
    // index = 2 时 bit[2] == 1  bit.nextClearBit == 3
    // index = 3 时 bit[3] == 0  bit.nextClearBit == 3
    // ...以此类推，当前bit[n]不为0时就从下一位找直到找到bit[n]为0的角标n
}

其余方法

// 将集合大小调整为当前实际容量
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
            ? EMPTY_ELEMENTDATA
            : Arrays.copyOf(elementData, size);
    }
}

// 返回此列表中的元素数
public int size() {
    return size;
}

// 如果此列表不包含元素，则返回 true 
public boolean isEmpty() {
    return size == 0;
}

// 如果此列表包含指定的元素，则返回 true 
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

// 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

// 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

// 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

// 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

@SuppressWarnings("unchecked")
E elementData(int index) {
    return (E) elementData[index];
}

// 返回此列表中指定位置的元素
public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

// 用指定的元素替换此列表中指定位置的元素
public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}


public ListIterator<E> listIterator(int index) {
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}

public ListIterator<E> listIterator() {
    return new ListItr(0);
}

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    ...
}

private class ListItr extends Itr implements ListIterator<E> {
    ...
}

public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}

private class SubList extends AbstractList<E> implements RandomAccess {
    ...
}