Java集合001 --- ArrayList源码解析

前言

List是一种有序、可以重复的数据结构，底层实现是动态数组或者链表；常用的List结构有：ArrayList、LinkedList、CopyOnWriteList还有古老的Vector和Stack。

先带着如下几个问题去学习ArrayList的源码：

1、ArrayList是怎么扩容的？

2、ArrayList的插入、删除、查询的时间复杂度？

3、怎么求两个集合的交集、并集、差集？

4、ArrayList怎么实现序列化和反序列化？

5、集合的toArray方法有什么问题？

ArrayList属性

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

// 空数组, 创建list时容量为0或者初始化集合为空时使用
private static final Object[] EMPTY_ELEMENTDATA = {};

// 空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 数组元素
transient Object[] elementData; // non-private to simplify nested class access

// 当前数组中有几个元素, 区别容量
private int size;

构造方法

ArrayList提供了如下三个构造方法:

1、指定初始容量

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

2、无参构造器

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

初始容量为0，第一次添加元素时，指定容量，默认是10

3、入参为集合类型构造器

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;
    }
}

流程为：先将输入集合转换成数组，然后赋值；这里为什么要判断elementData是不是Object类呢、或者说什么时候elementData不是Object类？

答案是在重写了ArrayList的toArray方法的类可能出现上述场景

添加单个元素方法

ArrayList提供了如下两个添加元素的方法：

1、添加单个元素到数组的最后（时间复杂度为O(1)）【返回boolean类型】

public boolean add(E e) {
    // 先做容量检查, 容量不够, 扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

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

private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 序列化时使用

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

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

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    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;
}

流程为：计算所需的最小容量，容量不够，做扩容处理，最后添加元素到末尾；这里重点说下扩容；

扩容机制为：先扩容1.5倍，如果还是不够分配需要的容量；如果大于Integer最大数值-8，则按照超大数组流程处理，防止整数溢出

2、添加单个元素到指定索引（涉及元素拷贝，时间复杂度为O(n)）【无返回值】

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++;
}

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

流程：1、验证索引，超上界or低于下界，抛IndexOutOfBoundsException异常（注意和ArrayIndexOutOfBoundsException的区别，ArrayIndexOutOfBoundsException为数组越界异常，IndexOutOfBoundsException为索引越界异常）

           2、扩容处理

           3、做元素拷贝：将index开始到结尾的元素拷贝到index+1到结尾

           4、元素复制&&元素个数加一

移除元素方法

1、移除指定索引的元素（时间复杂度为O(n)）【返回值为被删除的元素】

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;
}

2、移除指定元素（时间复杂度为O(n)）【返回值为删除结果boolean类型】

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 remove method that skips bounds checking and does not
 * return the value removed.
 */
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
}

这里注意的是：按需重写list对象的equals方法，否则默认的equals方法比较的是两个对象的地址

获取&修改元素方法

1、获取指定索引的元素（时间复杂度为O(1)）

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

2、修改指定索引的元素为指定值（时间复杂度为O(1)）【返回值为被修改的元素】

public E set(int index, E element) {
    rangeCheck(index);

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

求两个集合的并集

实际上就是在指定list中批量添加元素，提供了如下两个方法：

1、在末尾批量添加元素（时间复杂度为O(n)）【返回值为新添加元素个数是否为0（boolean）】

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray(); // 转换为数组
    int numNew = a.length;
    ensureCapacityInternal(size + numNew); // 扩容处理
    System.arraycopy(a, 0, elementData, size, numNew); // 元素拷贝到原数组末尾
    size += numNew;
    return numNew != 0;
}

2、在指定索引批量添加元素（时间复杂度为O(n)）【返回值为新添加元素个数是否为0（boolean）】

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index); // 上界&下界校验

    Object[] a = c.toArray(); // 转换为数组
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // 扩容处理

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved); // 先将原数组从index开始, 预留位置

    System.arraycopy(a, 0, elementData, index, numNew); // 将元素批量插入到index位置到index+numNew
    size += numNew;
    return numNew != 0;
}

求两个集合的交集（返回值为boolean类型, 表示原数组是否有改变）

public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, true);
}

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    // 读写指针, 写指针之前的元素是要保留的; 这样在原数组上操作, 节省空间
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // 理论上是r一定等于size的, 除非contains抛异常
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        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;
}

求两个集合的差集（返回值为boolean类型, 表示原数组是否有改变）

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

ArrayList序列化

从前面的属性中可以看到ArrayList的elementData由transient修饰的，是不参与序列化的，那么ArrayList怎么序列化呢？答案是ArrayList的writeObject方法和readObject方法

ArrayList通过这两个方法自己控制序列化

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // 记录list修改次数, 防止序列化期间list变化
    int expectedModCount = modCount;
    s.defaultWriteObject(); // 写入非静态 & 非transient属性

    s.writeInt(size); // 写入数据个数

    // 写入数组所有元素
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    // 序列化期间list变化, 抛出异常
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA; // 数组初始化
    // 去取非静态 & 非transient属性 & size
    s.defaultReadObject();

    // 读取数据个数, 没有卵用, 只是为了按照序列化步骤反序列化
    s.readInt(); // ignored

    if (size > 0) {
        // 计算容量
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        ensureCapacityInternal(size); // 扩容

        Object[] a = elementData;
        // 依次读取数据
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

为什么要这样序列化呢？我的理解，ArrayList存在容量远远大于size的情况（比如创建list时指定超大初始容量），按需序列化会大大减小内存占用

前面问题的答案

1、ArrayList是怎么扩容的？

      先扩容1.5倍，如果容量还是不够，按照需要的容量扩容 --> 如果是超大容量(Integer最大值-8)，检查是否可能整数溢出

2、ArrayList的插入、删除、查询的时间复杂度？

      插入：插入尾部O(1)，插入到指定索引O(n)

      删除：指定index和指定值都为O(n)，涉及数组拷贝

      查询：O(1)

3、怎么求两个集合的交集、并集、差集？

      交集：addAll(collection)、addAll(index, collection)

      并集:   remainAll()

      差集:   removeAll()

4、ArrayList怎么实现序列化和反序列化？

      自己实现私有的writeObject、readObject方法，按照实际元素个数序列化

5、集合的toArray方法有什么问题？