ArrayList 可以完全替代数组吗？

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    // new ArrayList() 默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

    // new ArrayList(0) 的全局空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // new ArrayList() 的全局空数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 修改次数记录
    protected transient int modCount = 0;

    // 数组的最大长度
    // 疑问 4：为什么 ArrayList 的最大容量是 Integer.MAX_VALUE，Long.MAX_VALUE 不行吗？
    // 疑问 5：为什么 ArrayList 的最大容量是 MAX_VALUE - 8，一定会减 8 吗？
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8

    // 疑问 1：为什么不声明 private（后文回答）
    // 疑问 2：为什么声明 transient（后文回答）
    // 疑问 3：为什么不声明为泛型类型 E
    // 底层数组
    transient Object[] elementData;

    // 数组的有效长度（不是 elementData.length）
    private int size;

    // size() 返回的是数组的有效长度（合理，底层数组我们不关心）
    public int size() {
        return size;
    }
}

// 带初始容量的构造方法
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 创建 initialCapacity 长度的数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 指向第 1 个全局空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 不合法的初始容量
        throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
    }
}

// 无参构造方法
public ArrayList() {
    // 指向第 1 个全局空数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 带集合的构造方法
public ArrayList(Collection<? extends E> c) {
    // 将集合转为数组
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // 疑问 7：这一个条件语句好奇怪，toArray() 的返回值类型就是 Object[] 啊？
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

OutOfMemoryError: Requested array size exceeds VM limit

// 在数组末尾添加元素
public boolean add(E e) {
    // 先确保底层数组容量足够容纳 size + 1，不足会扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 在 size + 1 的位置赋值
    elementData[size++] = e;
    return true;
}

// 在数组中间插入元素
public void add(int index, E element) {
    // 范围检查
    rangeCheckForAdd(index);
    // 先确保容量足够容纳 size + 1，不足会扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 先搬运数据腾出空位
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    // 在 index 的位置赋值
    elementData[index] = element;
    // 长度加一
    size++;
}

// 在数组末尾添加集合
public boolean addAll(Collection<? extends E> c) {
    // 集合转数组
    Object[] a = c.toArray();
    // 先确保底层数组容量足够容纳 size + numNew，不足会扩容
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    // 搬运原数据
    System.arraycopy(a, 0, elementData, size, numNew);
    // 长度加 numNew
    size += numNew;
    return numNew != 0;
}

// 在数组中间插入集合
public boolean addAll(int index, Collection<? extends E> c) {
    // 略，原理类似
}

// 尝试扩容
// （提示：源码调用了 calculateCapacity() 函数，这里做内联简化）
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++;
    // 疑问 8：不应该是 elementData.length - minCapacity > 0 吗？
    // 如果底层数组长度不够 minCapacity 最小容量要求，则需要扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // 旧容量
    int oldCapacity = elementData.length;
    // 新容量 = 旧容量 * 1.5 倍（有可能整型溢出）
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果新容量小于最小容量要求，则使用最小容量（addAll 大集合的情况）
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    // （提示：上一个 if 的 newCapacity 有可能是溢出的）
    // 如果新容量超出最大数组长度限制，说明无法扩容 1.5 倍，回归到 minCapacity 上
    // （提示：源码调用了 hugeCapacity() 函数，这里做内联简化）
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        // 最小容量要求发生整型溢出，无法满足要求，只能直接抛出 OOM
        if (minCapacity < 0) throw new OutOfMemoryError();
        // 如果最小容量要求超出最大数组长度限制，则扩容到 MAX_VALUE（说明不一定会减 8）
        // 否则，扩容到最大数组长度限制（MAX_VALUE - 8）
        newCapacity = (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }
    // 扩容到 newCapacity 长度
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    // 已经内联简化到 grow 方法中
}

// 缩容
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    // 创建迭代器是会记录外部类的 modCount
    int expectedModCount = modCount;
    ...

    Itr() {}

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        // 检查
        checkForComodification();
        ...
    }

    public void remove() {
        ...
        // 更新
        expectedModCount = modCount;
    }
}

// 序列化和反序列化只考虑有效元素
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // 写入数组长度
    s.writeInt(size);

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

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

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        // 拷贝数组对象
        v.elementData = Arrays.copyOf(elementData, size);
        // 修改计数归零
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(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 {
    // 原 ArrayList
    private final AbstractList<E> parent;
    private final int parentOffset;
    private final int offset;
    int size;

    SubList(AbstractList<E> parent, int offset, int fromIndex, int toIndex) {
        this.parent = parent;
        this.parentOffset = fromIndex;
        this.offset = offset + fromIndex;
        this.size = toIndex - fromIndex;
        // modCount 记录
        this.modCount = ArrayList.this.modCount;
    }

    public E set(int index, E e) {
        rangeCheck(index);
        // 在 ArrayList 上增加或删除元素，会导致 SubList 抛出 ConcurrentModificationException 异常
        checkForComodification();
        // 在 SubList 上增加或删除元素，会影响到 ArrayList；
        E oldValue = ArrayList.this.elementData(offset + index);
        ArrayList.this.elementData[offset + index] = e;
        return oldValue;
    }
}

// 假设没有特殊处理
List<String> list = new ArrayList<>(Arrays.asList("list"));
// class java.util.ArrayList
System.out.println(list.getClass());

Object[] listArray = list.toArray();
// 如果过没有特殊处理，实际类型是 [Ljava.lang
System.out.println(listArray.getClass());
// 如果过没有特殊处理，将抛出 ArrayStoreException 异常
listArray[0] = new Object();

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable {
    // 泛型擦除后：Object[] a;
    private final E[] a;

    // 泛型擦除后：Object[] array;
    // Java 数组是协变的，能够接收 String[] 类型的数组
    ArrayList(E[] array) {
        // 赋值
        a = Objects.requireNonNull(array);
    }

    // 实际返回的数组可能是 Object[] 类型，也可能是 String[] 类型
    @Override
    public Object[] toArray() {
        return a.clone();
    }
}

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    transient Object[] elementData;

    // 带集合的构造方法
    public ArrayList(Collection<? extends E> c) {
        // 将集合转为数组
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // 疑问 7：这一个条件语句好奇怪，toArray() 的返回值类型就是 Object[] 啊？
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
}