java-ArrayList详解-优快云博客

本文链接：https://blog.youkuaiyun.com/HelloKittyTom/article/details/145544800

前言：

ArrayList 是 Java 中最常用的集合类之一，它基于动态数组实现，允许存储重复元素，并且支持随机访问

类定义和成员变量

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

    // 存储ArrayList元素的数组缓冲区
    transient Object[] elementData; // non-private to simplify nested class access

    // ArrayList中元素的数量
    private int size;
}

DEFAULT_CAPACITY：默认初始容量为 10。
EMPTY_ELEMENTDATA 和
DEFAULTCAPACITY_EMPTY_ELEMENTDATA：用于区分空实例和默认大小的空实例。
elementData：存储元素的数组缓冲区，transient 表示该字段不会被序列化。
size：当前 ArrayList 中元素的数量。

构造方法

提供三个构造方法

// 构造一个初始容量为10的空列表
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_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);
    }
}

// 构造一个包含指定集合元素的列表
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

无参构造方法：创建一个初始容量为 10 的空列表。
指定初始容量的构造方法：创建一个指定初始容量的空列表。
使用集合构造方法：创建一个包含指定集合元素的列表。

核心方法

添加元素

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 确保容量足够
    elementData[size++] = e;
    return 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++; // 修改次数增加

    // 如果最小容量大于当前数组长度，则进行扩容
    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;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

add(E e)：添加元素到列表末尾。
ensureCapacityInternal(int minCapacity)：确保内部容量足够。
grow(int minCapacity)：扩容机制，新容量为旧容量的 1.5 倍。

获取元素

public E get(int index) {
    rangeCheck(index); // 检查索引是否越界
    return elementData(index);
}

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

E elementData(int index) {
    return (E) elementData[index];
}

get(int index)：获取指定索引位置的元素。
rangeCheck(int index)：检查索引是否越界。

删除元素

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; // 清除引用，帮助GC

    return oldValue;
}

remove(int index)：删除指定索引位置的元素。
System.arraycopy：将数组中的元素向前移动，覆盖被删除的元素。

修改元素

public E set(int index, E element) {
    rangeCheck(index); // 检查索引是否越界

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

set(int index, E element)：修改指定索引位置的元素。

其他方法

size()：返回列表中的元素数量。
isEmpty()：判断列表是否为空。
contains(Object o)：判断列表是否包含指定元素。
indexOf(Object o)：返回指定元素在列表中首次出现的索引。
clear()：清空列表中的所有元素。

序列化

ArrayList 实现了 Serializable 接口，支持序列化。由于 elementData 是 transient 的，ArrayList 自定义了序列化和反序列化的逻辑：

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException {
    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();
    }
}

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

    s.defaultReadObject();

    s.readInt(); // 读取size，忽略

    if (size > 0) {
        ensureCapacityInternal(size);

        Object[] a = elementData;
        for (int i = 0; i < size; i++) {
            a[i] = s.readObject();
        }
    }
}