ArrayList

参考： 死磕 java集合 by 彤哥读源码

1. 概述

1.1 简介

• ArrayList是一种以动态数组实现的List，能在常数时间内随机访问元素，但非尾部的插入和删除需要线性时间，需要移动元素
• 同时数组元素的存储在物理上是连续的，因此其存取可能极大得益于CPU缓存

1.2 继承体系

• ArrayList实现了List，提供了基础的基于索引的添加、删除、遍历等操作
• ArrayList实现了RandomAccess，提供了随机访问的能力
• ArrayList实现了Cloneable，可以被克隆
• ArrayList实现了Serializable，可以被序列化

2. 源码解析

2.1 属性

// 默认容量
private static final int DEFAULT_CAPACITY = 10;
// new ArrayList(0)或0个元素集合初始化时使用
private static final Object[] EMPTY_ELEMENTDATA = {};
// new ArrayList()使用
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 存储元素的数组
transient Object[] elementData;
// 元素个数
private int size;

2.2 构造函数

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) {
        // 以前的一个bug, 以前的Arrays.asList返回的List#toArray返回的不一定是Object[]类型
        // elementData原来是Object[]类型, elementData[i]可以存储任意引用类型
        // 当String[]赋予elementData后, elementData[i]就只能存储String类型了
        // 而ArrayList代码内是将element[i]当作Object操作的, 可能就会出问题
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 集合没有元素, 带参构造函数的空容器就是EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

2.3 常规操作

 

public boolean add(E e)

将元素添加到末尾，平均时间复杂度O(1)

public boolean add(E e) {
    // add操作是一个Structural modification
    modCount++;
    // 末尾添加
    add(e, elementData, size);
    // 一定成功, 失败那就是OOM了
    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)

// 指定索引插入
public void add(int index, E element) {
    // index有效性检查
    rangeCheckForAdd(index);
    // 实际插入是一个Structural modification操作
    modCount++;
    // 保存size的temp变量
    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;
}

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 E remove(int index) {
    rangeCheck(index);

    // remove也是一个 Structural modification操作
    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) {
    // 分为null和非null查找, 找到index然后进行index的shanc
    // 相等性比较使用的是equals
    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++)
            // equals进行相等性比较
            if (o.equals(elementData[index])) {
                fastRemove(index);
            return true;
        }
    }
    
    // 未删除任何元素, 返回false
    return false;
}

// 快速删除: 不进行index检查, 不返回删除元素
private void fastRemove(int index) {
    // 插入是一个Structural modification操作
    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
}

2.4 参数为集合的操作

// 尾插一个集合
public boolean addAll(Collection<? extends E> c) {
    // 转数组后再对数组进行操作
    Object[] a = c.toArray();
    // 插入是一个Structural modification操作
    modCount++;
    int numNew = a.length;
    // 无需要插入的元素
    if (numNew == 0)
        return false;
    Object[] elementData;
    final int s;
    // 空闲位置不够插入, 进行扩容
    if (numNew > (elementData = this.elementData).length - (s = size))
            elementData = grow(s + numNew);
    // 复制
    System.arraycopy(a, 0, elementData, s, numNew);
    size = s + numNew;
    return true;
}

// 范围内批量删除操作, complement为false表示删除c中存在的元素, true删除c不存在的元素
// 以下以删除为例
boolean batchRemove(Collection<?> c, boolean complement,
                    final int from, final int end) {
    Objects.requireNonNull(c);
    final Object[] es = elementData;
    int r;
    // Optimize for initial run of survivors
    // 如果传入集合不含本集合返回内元素, 返回
    for (r = from;; r++) {
        if (r == end)
            return false;
        if (c.contains(es[r]) != complement)
            break;
    }
    
    // elementData[r]是第一个双方都存在的元素
    // r读指针, w写指针, w指向第一个双方都存在的元素索引, r指向后一个元素
    int w = r++;
    try {
        for (Object e; r < end; r++)
            // complement == false, 不包含则向elementData[w]写入
            // 初始[w]指向相等元素, 第一次写入的是es存在而c不存在的【不需要删除的】, 相当于[w]被删除了
            // 可使用循环不变式的思想思考其正确性
            if (c.contains(e = es[r]) == complement)
                es[w++] = e;
    } catch (Throwable ex) {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        // 将未读元素复制到写指针之后, 即删除的就删除的, 其它的元素继续保存
        System.arraycopy(es, r, es, w, end - r);
        // 保证[w, end)内元素是无效的, 即应该被删除的
        w += end - r;
        throw ex;
    } finally {
        // modCount += end - w ===> modCount += (end - w);
        modCount += end - w;
        // 删除无效元素
        shiftTailOverGap(es, w, end);
    }
    return true;
}


/** Erases the gap from lo to hi, by sliding down following elements. */
// elementData内元素分为: [0, low)有效, [low, hight)无效, [hight, size)有效
private void shiftTailOverGap(Object[] es, int lo, int hi) {
    // 将[hight, size)前移变为[low, ?)
    System.arraycopy(es, hi, es, lo, size - hi);
    // 无效位置置null, i = (size -= hi - lo) ===> i = (size -= (hi - lo))
    for (int to = size, i = (size -= hi - lo); i < to; i++)
        es[i] = null;
}

// 保留双方都存在的元素, 求交集
public boolean retainAll(Collection<?> c) {
    // 
    return batchRemove(c, true, 0, size);
}

2.5 JDK8及以后的操作（基本涉及函数式接口及Lambda表达式）

public boolean removeIf(Predicate<? super E> filter) {
    return removeIf(filter, 0, size);
}

// 删除满条件的元素, Predicate 谓词
boolean removeIf(Predicate<? super E> filter, int i, final int end) {
    Objects.requireNonNull(filter);
    int expectedModCount = modCount;
    final Object[] es = elementData;
    // 找到第一个满足的
    for (; i < end && !filter.test(elementAt(es, i)); i++)
        ;
    // Tolerate predicates that reentrantly access the collection for
    // read (but writers still get CME), so traverse once to find
    // elements to delete, a second pass to physically expunge.
    if (i < end) {
        final int beg = i;
        // 使用bitmap算法保存无效内容, 使用long型保存
        // 每一个位标记一个位置, long可标记64个元素
        // long[] nBits(int n) -> new long[((n - 1) >> 6) + 1]
        final long[] deathRow = nBits(end - beg);
        // 第一个元元素必然是无效的
        deathRow[0] = 1L; 
        // 先找出全部无效元素
        for (i = beg + 1; i < end; i++)
            if (filter.test(elementAt(es, i)))
                // 此位置元素无效, 1L << num, 当num=63时移到最高位, num=64时绕回来了, 移位数0, 65移一位, ...
                // setBit(long[] bits, int i) -> bits[i >> 6] |= (1L << i)
                setBit(deathRow, i - beg);
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        modCount++;
        // 开始写了, 将有效元素全部往前写
        int w = beg;
        for (i = beg; i < end; i++)
            // 为0表示有效, 无效的都被标记了
            // boolean isClear(long[] bits, int i) -> (bits[i >> 6] & (1L << i)) == 0
            if (isClear(deathRow, i - beg))
                es[w++] = es[i];
        // 有效数据[end, size)前移到从w开始, 无效数据赋值null删除
        shiftTailOverGap(es, w, end);
        return true;
    } else {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        return false;
    }
}

public void forEach(Consumer<? super E> action)

2.6 扩容策略（基本add之前都要先判断）

// 这个一般是使用者调用, 用来避免频繁扩容的
public void ensureCapacity(int minCapacity) {
    // 未使用过(调用的是默认构造函数) 若请求容量小于10不做处理, 大于等于则扩容请求容量
    // 其它 若请求容量不到elementData.length不做处理, 否则扩容max(1.5倍, 请求容量)
    if (minCapacity > elementData.length
        && !(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
             && minCapacity <= DEFAULT_CAPACITY)) {
        modCount++;
        grow(minCapacity);
    }
}


// new ArrayList()扩容DEFAULT_CAPACITY
// new ArrayList(initCapacity)或存在元素扩容1.5倍
private Object[] grow(int minCapacity) {
    // 
    int oldCapacity = elementData.length;
    // 不是new ArrayList()默认构造后立即添加元素导致的grow()扩容
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 默认扩容 max(1.5倍, 请求容量), 请求容量一般为1
        int newCapacity = ArraysSupport.newLength(oldCapacity,
            minCapacity - oldCapacity, /* minimum growth */
            oldCapacity >> 1           /* preferred growth */);
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        // new ArrayList()后立即添加元素导致grow()扩容为 max(默认容量10, 请求容量)
        // 请求容量大于1的情况是批量添加时
        // 即保证容量大于等于默认容量, 避免频繁扩容
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

// 默认扩容 max(1.5倍, 请求容量)
public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
    int newLength = Math.max(minGrowth, prefGrowth) + oldLength;
    if (newLength - MAX_ARRAY_LENGTH <= 0) {
        return newLength;
    }
    return hugeLength(oldLength, minGrowth);
}

// 
private static int hugeLength(int oldLength, int minGrowth) {
    // 请求容量太大, OOM
    int minLength = oldLength + minGrowth;
    if (minLength < 0) { // overflow
        throw new OutOfMemoryError("Required array length too large");
    }
    // 小于等于MAX_ARRAY_LENGTH(Integer.MAX_VALUE-8)
    if (minLength <= MAX_ARRAY_LENGTH) {
        return MAX_ARRAY_LENGTH;
    }
    return Integer.MAX_VALUE;
}

• 默认容量10
• 默认构造函数扩容后一般扩容为0，若是批量添加元素，则扩容为 max(10，批量添加的元素数量)
• 非默认构造函数扩容一般扩容为 原来的1.5倍

2.7 重要的工具方法

Arrays#

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    // new 一个指定长度的 newType.getComponentType()数组
    // ArrayList需要的Object[]
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        
    // 元素复制
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

System.arraycopy

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

// 元素赋值（这是最终调用的，中间检查环境省略了）
// 不会创建temp数组, 赋值效率还是很高的
static void pd_conjoint_jints_atomic(jint* from, jint* to, size_t count) {
    // 从前往后复制
    if (from > to) {
        while (count-- > 0) {
        // Copy forwards
        *to++ = *from++;
        }
    } else {
        // 从后往前复制
        from += count - 1;
        to   += count - 1;
        while (count-- > 0) {
        // Copy backwards
        *to-- = *from--;
    }
  }
}

4. JDK序列化方式

// 使用了transient修饰，不会被默认序列化，需要自己处理其序列化
transient Object[] elementData;

// 使用了 transient 修饰, 不会被默认序列化, 需要手动处理
// elementData 使用 transient 修饰的原因是一般而言数组空间是不会被刚好用尽的
// 而序列化会保存整个数组内元素, 而没有使用的空间序列化是没有意义的, 还占空间
transient Object[] elementData;
// 不会被序列化, 即最后反序列化后默认0值，可能是反序列化后还保存这个值没有啥意义
protected transient int modCount = 0;

// 序列化
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    int expectedModCount = modCount;
    // 写入默认要序列化的字段(没有被static和transient修饰的字段)
    s.defaultWriteObject();

    // Write out size as capacity for behavioral compatibility with clone()
    // 写入元素数量 ?
    s.writeInt(size);

    // 写入有效元素
    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 {

    // 反序列化默认字段
    s.defaultReadObject();

    // 反序列化size, 只是因为序列化时还重复序列化了这个字段
    s.readInt(); // ignored

    if (size > 0) {
        // 开辟size数量的空间存储元素
        SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Object[].class, size);
        Object[] elements = new Object[size];

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

        elementData = elements;
    } else if (size == 0) {
        elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new java.io.InvalidObjectException("Invalid size: " + size);
    }
}

3. 总结

1. ArrayList内部使用数组存储元素，当数组长度不够时进行扩容，每次加一半的空间，ArrayList不会主动进行缩容；
2. ArrayList支持随机访问，通过索引访问元素极快，时间复杂度为O(1)；
3. ArrayList添加元素到尾部极快，平均时间复杂度为O(1)；
4. ArrayList添加元素到中间比较慢，因为要搬移元素，平均时间复杂度为O(n)；
5. ArrayList从尾部删除元素极快，时间复杂度为O(1)；
6. ArrayList从中间删除元素比较慢，因为要搬移元素，平均时间复杂度为O(n)；
7. ArrayList支持求并集，调用addAll(Collection<? extends E> c)方法即可
8. ArrayList支持求交集，调用retainAll(Collection<? extends E> c)方法即可
9. ArrayList支持求单向差集，调用removeAll(Collection<? extends E> c)方法即可