深度解析ArrayList：灵活高效的动态数组实现

修己xj

已于 2023-12-07 00:19:16 修改

阅读量967

点赞数 27

分类专栏：八股文 java基础文章标签： java

于 2023-12-06 23:51:26 首次发布

本文链接：https://blog.csdn.net/weixin_44002151/article/details/134843958

版权

八股文同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

java基础

8 篇文章 0 订阅

订阅专栏

本文深入剖析了Java中的ArrayList类，介绍了其作为动态数组的底层实现、容量管理、添加/删除操作、序列化机制以及适用场景。重点强调了其高效随机访问和动态调整容量的特点，以及在选择集合类时的考虑因素。

摘要由CSDN通过智能技术生成

在 Java 集合框架中，ArrayList 是一个常用而强大的类，它提供了动态数组的实现，允许在运行时动态调整数组的大小。
ArrayList 是 List 接口的实现类，基于动态数组的数据结构。它可以存储任意类型的对象，并提供了丰富的方法，包括添加、删除、遍历等，使其在各种场景下都能发挥重要作用。

底层数据结构

ArrayList 的底层数据结构是动态数组，其容量是动态调整的。这意味着 ArrayList 可以根据需要自动增长或缩小。

比如有一个ArrayList,size = 3;

ArrayList属性源码如下：

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;
    
    // 空数组实例，用于空 ArrayList 的初始值
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // 默认大小的空数组实例，用于默认初始容量的 ArrayList
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 存储ArrayList元素的数组。
    // ArrayList的容量就是这个数组的长度。
    // 任何elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList，
    // 在添加第一个元素时会扩展为DEFAULT_CAPACITY。
    transient Object[] elementData; // non-private to simplify nested class access

    // ArrayList 的大小（元素的数量）
    private int size;
    
    //带初始化容量参数的构造方法
    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;
    }
    
    .
    .
    .
}

从源码可以看到，elementData数组是实际存储元素的地方。size变量跟踪ArrayList的大小。当你向ArrayList中添加元素时，它们会存储在elementData数组中，并相应地更新size。

对于 ArrayList 中的 elementData 字段，它被声明为 transient 的目的是在序列化时避免将数组内容直接序列化到持久存储中。这是因为 ArrayList 的实际元素可能只占用数组的一部分，而不是整个数组。在反序列化时，elementData 会在构造对象时被重新初始化。

在 ArrayList 类中，具体的反序列化过程是通过实现 readObject 方法来完成的。在该方法中，elementData 被重新赋值，以便在反序列化后正确恢复 ArrayList 对象。

以下是 ArrayList 中的关键部分，用于反序列化：

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // 将 elementData 初始化为 EMPTY_ELEMENTDATA
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        ensureCapacityInternal(size);

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

初始化容量

在使用 new ArrayList() 初始化时，ArrayList 的内部数组 elementData 初始化为一个空数组（EMPTY_ELEMENTDATA），并在添加第一个元素时才进行实际的初始化和分配。默认情况下，ArrayList 的初始容量为 10，即创建一个长度为 10 的空数组。当向 ArrayList 添加元素时，如果容量不足，会触发扩容机制，将数组长度扩大为原来的 1.5 倍。

                              
//带初始化容量参数的构造方法
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;
}

扩容机制

ArrayList 的扩容机制是在 ensureCapacityInternal 和 grow 方法中实现的。当元素个数达到当前容量时，会触发扩容，将数组长度扩大为原来的 1.5 倍。

当我们向ArrayList 中添加元素(调用add()或者addAll())时,都调用了一个ensureCapacityInternal（）方法

我们来看源码：

add()

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

addAll()

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

从源码可以看到，这两个方法都调用了ensureCapacityInternal（）这个方法，参数是当前list的长度加上要插入的对象个数（单个对象的话为1，对象集合的话是集合的长度），既集合添加元素所需最小的长度

ensureCapacityInternal（）

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

ensureExplicitCapacity() 方法的入参是calculateCapacity（）（参数是存储实际元素的数组和集合添加元素所需最小的长度）方法处理后的值。

calculateCapacity（）

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

当前方法返回的值是如果源集合是空的，则返回默认容量（10）和元素集合添加元素所需最小的长度值比较，值大的一个，若不为空则返回minCapacity。

ensureExplicitCapacity()

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

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

grow()

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