Java中ArrayList集合的扩容机制

目录

引言

源代码

总结

---

引言

在Java中，ArrayList是最常用的集合之一。它是一种容器，它的内部定义了一个Object类型的数组elementData，因此可用于存储任意类型的数据。我们知道，数组是长度恒定的。而ArrayList相当于是一个长度可变的动态数组，一起来看看的它的扩容机制。

源代码

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
 ......
    private int size;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //定义的空数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    transient Object[] elementData; // non-private to simplify nested class access
    //无参的构造方法
      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);
        }
    }
......

}

如果使用无参的构造方法创造一个ArrayList集合对象，那么就默认让这个数组指向一个空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA；它是一个私有的，静态的常量。也就是只要是通过无参构造方法创建ArrayList对象，无论创建多少个，每个ArrayList内部的elementData都指向那个空数组，没有重新new，这一点也节省了内存空间！

如果使用有参的构造方法，就会根据传入的长度，创建出新的Object[]类型数组，并让elementData指向它。这里讨论的是扩容机制，就先不介绍其他的构造方法。

添加元素

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
  
       private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

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

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

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

ArrayList内部定义了一个私有变量size，它时刻记录着当前集合存储的元素个数。使用add()方法添加元素时：

1.调用ensureCapacityInternal(int minCapacity )方法传入“size+1”(最小容量)看是否需要扩容，

2.在ensureCapacityInternal(int minCapacity )方法内，调用calculateCapacity(Object[] elementData, int minCapacity) 将elementData和"最小容量"传入,

3.在calculateCapacity(Object[] elementData, int minCapacity)方法内， 判断elementData是不是默认的空数组，如果是，就返回默认容量DEFAULT_CAPACITY（10）和最小容量minCapacity中较大的值，否则返回最小容量minCapacity。记这个值为value

4.当ensureExplicitCapacity()方法拿到这个值value , 就用它减去原数组elementData的长度 看是否大于0（原数组elementData容量不够），如果大于0，就调用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);
    }
      private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

5.在grow()方法中，按照oldCapacity + (oldCapacity >> 1）进行计算新的容量newCapacity，相当于是计算原数组的1.5倍容量。如果这个容量比最小容量要小，那么newCapacity就重新赋值为minCapacity。如果最小容量minCapacity比默认的容量MAX_ARRAY_SIZE还要大，就会调用hugeCapacity(int minCapacity)方法，最后得到Inteter.MAX_VALUE或Integer.MAX_VALUE-8 ，然后通过Arrays.copyOf()方法创建出新的数组，并将原来数组的值复制至新的数组中。

总结

1.如果使用无参构造方法创建ArrayList对象，那么在第一次添加元素时就会扩容为10，当要添加第11个元素时 ，按照1.5倍进行扩容。往后但凡超过数组容量，都按照1.5倍进行扩容。然后按照新容量创建出数组，将原数组内容复制至新数组。同时elementData指向新数组。

2.如果是有有参的构造方法创建ArrayList对象，那么当添加元素至超过elementData容量时，按照原数组1.5倍容量进行扩容。

3.ArrayList的最大容量为 Inteter.MAX_VALUE或Integer.MAX_VALUE-8;

4.在使用ArrayLIst之前，可以先估计要存储元素的个数。使用有参构造方法创建对象，这样可以减少扩容次数，减少内存开销。