ArrayList源码详细解析

ArrayList源码详细解析

1.成员变量的介绍

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8683452581122892189L; // 序列化版本号

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

    private static final Object[] EMPTY_ELEMENTDATA = {}; // 空数组实例

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空数组实例
    
    transient Object[] elementData; // 实际存储元素的数组缓冲区

    private int size; // 列表的大小

这段代码是 ArrayList 类的声明部分，其中指定了类名、泛型类型 E，以及实现的接口（AbstractList、List、RandomAccess、Cloneable 和 Serializable）。它还包括了用于序列化的 serialVersionUID，以及默认容量和空元素数据数组的静态 final 变量。

在 Java 中，transient 关键字用于修饰类的成员变量，表示这些变量不会被序列化。当一个对象需要被序列化成字节流以便进行存储或传输时，transient 修饰的变量不会被包含在序列化的结果中。

在 ArrayList 的源码中，transient 修饰的 elementData 变量表示这个数组不会被默认的 Java 序列化机制所序列化。这是因为 ArrayList 在序列化时，并不需要将数组的所有内容都序列化，而只需要序列化其中存储的元素以及列表的其他状态信息，例如列表的大小。因此，为了提高序列化的效率并避免将不必要的数据写入序列化结果中，elementData 被标记为 transient。

另外，ArrayList 中的 elementData 数组在序列化时并不是直接写入输出流的，而是通过其他的序列化逻辑来处理。这意味着即使 elementData 被标记为 transient，ArrayList 仍然可以正确地进行序列化和反序列化，因为在序列化和反序列化过程中，ArrayList 类会提供自定义的序列化和反序列化逻辑来处理 elementData 数组。

2.构造方法

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_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);
    }
}

这些是 ArrayList 的构造函数。默认构造函数将 elementData 初始化为一个空数组，而带初始容量参数的构造函数如果指定的容量大于零，则分配一个新数组，如果容量为零，则分配一个空数组。如果容量为负数，则抛出异常。

3.add方法

public boolean add(E e) {
    ensureCapacityInternal(size + 1); // 确保总容量足以容纳新元素
    elementData[size++] = e; // 将新元素e添加到数组的当前size位置，然后size增加1
    return true; // 总是返回true，表示添加成功
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); // 如果当前数组是默认的空数组，将最小容量设置为默认容量或所需的更大值
    }
    ensureExplicitCapacity(minCapacity); // 调用以确保数组具有足够的容量
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 增加modCount，该变量用于记录数组结构修改的次数
    if (minCapacity - elementData.length > 0)
        grow(minCapacity); // 如果所需的最小容量大于当前数组长度，执行扩容操作
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length; // 当前数组容量
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量为当前容量的1.5倍
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity; // 如果1.5倍仍不满足最小容量要求，直接使用所需的最小容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity); // 如果新容量超过最大数组大小限制，使用hugeCapacity方法处理
    elementData = Arrays.copyOf(elementData, newCapacity); // 使用Arrays.copyOf扩容数组
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError(); // 如果最小容量小于0，抛出内存溢出错误
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; // 如果所需容量超过最大数组大小，则返回整数的最大值或最大数组大小
}

这些方法负责向 ArrayList 中添加元素。add(E e) 方法将元素添加到列表的末尾，并在需要时确保容量足够。它调用 ensureCapacityInternal() 来确保容量足够，这又调用 ensureExplicitCapacity() 来处理必要的大小调整。grow() 方法负责通过增加内部数组的容量来调整大小。

4.其他常用方法

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); // 检查索引是否合法
    modCount++; // 修改次数加一
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    elementData[--size] = null; // 删除指定位置的元素并将后续元素向前移动
    return oldValue;
}

public void clear() {
    modCount++; // 修改次数加一
    for (int i = 0; i < size; i++)
        elementData[i] = null; // 清空数组
    size = 0; // 重置大小为0
}

public int size() {
    return size; // 返回列表的大小
}

public boolean isEmpty() {
    return size == 0; // 判断列表是否为空
}

这些是 ArrayList 的一些其他常用方法。get(int index) 获取指定索引位置的元素，set(int index, E element) 替换指定索引位置的元素，remove(int index) 删除指定索引位置的元素，clear() 清空列表，size() 返回列表的大小，isEmpty() 检查列表是否为空。

5.总结

ArrayList 是 Java 中的一个动态数组实现，它继承自 AbstractList，实现了 List 接口。其底层逻辑主要基于数组实现，通过数组来存储元素，并在需要时进行动态扩容以支持添加更多的元素。

数据结构和思想：

1. 数组实现：
   ArrayList 内部维护一个 elementData 数组，用于存储元素。数组的元素类型是泛型 E，允许存储任意类型的元素。

2. 动态扩容：
   当添加元素时，如果当前数组容量不足，就需要进行扩容。这是为了避免在添加元素时频繁地进行数组复制，从而提高性能。
   扩容时，一般会创建一个新的数组，将原数组中的元素复制到新数组中，同时确保新数组具有足够的容量来存储新增的元素。

3. 增量式扩容：
   ArrayList 通过每次扩容都增加一定的容量来避免频繁的扩容操作。通常是将当前容量的一半作为增量进行扩容，即 newCapacity = oldCapacity + (oldCapacity >> 1)。
   这种增量式的扩容策略能够在一定程度上平衡内存的利用率和扩容的频率。

4. 性能特点：
   在尾部添加元素的时间复杂度是常数时间 O(1)，因为在尾部添加元素时不需要移动其他元素。
   在数组中间或开头添加元素时，需要移动后续元素，时间复杂度是 O(n)。
   扩容操作的时间复杂度是 O(n)，但由于扩容发生的次数相对较少，因此均摊下来仍然是 O(1)。

5. 随机访问：
   由于 ArrayList 底层基于数组实现，因此支持通过索引进行快速随机访问，时间复杂度为 O(1)。

   综上所述，ArrayList 通过数组实现了一个动态的、可变长度的容器，能够高效地支持元素的添加、删除和随机访问操作。其核心思想是在保证性能的前提下动态扩容，以满足不同场景下的需求。