【Java 集合源码】ArrayList 源码分析

ArrayList

1，概念

ArrayList 是 List 接口的一个实现类，底层基于数组实现，具有查询快、增删慢；非线程安全，效率高的特点。同时，ArrayList 还具备了 List 接口的有序、可重复的特点，且允许插入空值。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

2，源码分析

（如无特殊说明，我们一般取 JDK1.8 做分析）

我们主要看一下 ArrayList 的动态扩容机制：

2.1，基本属性

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

private static final Object[] EMPTY_ELEMENTDATA = {}; //有参构造为 0 时的空数组

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//无参构造时的空数组

transient Object[] elementData //不可序列化的对象数组
    
private int size; //实际元素个数

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 最大容量

2.2，构造方法

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) {
            // 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;
        

2.3，主要方法

我们主要讲一下 ArrayList 的动态扩容机制，此过程会涉及到主要方法的使用：

• ArrayList 在使用无参构造器构造函数时，默认初始 elementData 为 0；当第一次添加

  add 时，容量置为 10；之后若再次扩容，容量为 elementData 的 1.5 倍。

• ArrayList 在使用有参构造器构造函数时，默认初始为 指定大小，再次扩容时以 elementData 的 1.5 倍进行扩容。

扩容机制的方法执行过程：

在执行元素添加时，size 初始为 0，即每次添加一个，容量也加一，非常节省空间！

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

ensureCapacityInternal 内部方法，以最省容量作为最小容量。可以看到空参构造时初始 elementData 为 0，所以第一次 add 时，最小容量便被置为 DEFAULT_CAPACITY 等于 10；

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

随后执行真正扩容逻辑 ensureExplicitCapacity，当且仅当最小容量（即实际长度）开始超过缓冲区长度时，执行第二次扩容机制 grow 方法；

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++; //表示修改次数

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

首先取当前 elementData 的实际大小，然后执行newCapacity = oldCapacity + (oldCapacity >> 1)机制，使得新的数组容量为之前的（10 的）1.5 倍；

如果新的扩容容量仍然小于当前需要的最小容量，则当前最小容量为新的扩容容量；

如果新的扩容容量大于临界值，则进行大容量分配 hugeCapacity；

最终的扩容数组是基于当前数组和新的扩容容量的追加拷贝。

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

如果想要的容量大于 MAX_ARRAY_SIZE，则分配 Integer.MAX_VALUE，否则分配 MAX_ARRAY_SIZE。其中：MAX.VALUE 为 0x7fffffff，转换成十进制就是 2147483647，也就是数组的最大长度是 2147483639

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

参考链接

• https://blog.csdn.net/u010250240/article/details/89762912