集合学习2——ArrayList的扩容机制

1 ArrayList

ArrayList是List接口的一个实现类，ArrayList中维护了一个Object类型的数组elementData。数据的存放就是放在这个elementData这个成员变量中。与数组存放指定长度的元素不同，elementData这个成员变量的长度是随着元素的存放动态地变化。该变化与ArrayList的初始构造方法有关。

当创建ArrayList对象时，如果使用的是无参数构造器，如上图的ArrayList（），则初始elementData的容量为0。第一次添加元素时，则elementData为10。当元素添加直至10时，到下一次添加元素时，将会按照elementData扩容1.5倍。
如果使用的是指定大小的构造器，如上图的ArrayList（int），则elementData的容量即为构造函数中设置的大小，如果需要扩容，则直接扩大为elementData初始长度的1.5倍

2 ArrayList扩容机制源码分析【JDK8】

2.1无参数构造

public class ArrayListPractice {

    public static void main(String[] args) {


        //无参数构造创建ArrayList对象
        // public ArrayList() {
        //        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        // }
        //elementData初始化为{}
        ArrayList list = new ArrayList();

        for (int i = 1; i <= 10; i++) {
            //第一次添加元素
            //   public boolean add(E e) {
            //        ensureCapacityInternal(size + 1);  // 先确定是否需要扩容
            //        elementData[size++] = e;//执行赋值
            //        return true;
            //    }


            //    private static int calculateCapacity(Object[] elementData, int minCapacity) {
            //        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //            return Math.max(DEFAULT_CAPACITY, minCapacity);  // DEFAULT_CAPACITY=10与初始值1间的最大值
            //        }
            //        return minCapacity; //minCapacity 此时为10
            //    }


            //    private void ensureExplicitCapacity(int minCapacity) {
            //        modCount++; //记录当前集合被修改的次数
            //
            //        //如果elementData的大小不够了，就进行扩容方法。将elementData扩大1.5倍
            //        //否则不需要扩容
            //        if (minCapacity - elementData.length > 0)
            //            grow(minCapacity);
            //    }

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

            //集合扩容 minCapacity=10
            //    private void grow(int minCapacity) {
            //        // overflow-conscious code
            //        int oldCapacity = elementData.length;
            //        int newCapacity = oldCapacity + (oldCapacity >> 1); //等价于oldCapacity +oldCapacity /2 即扩容到原elementData数组长读的1.5倍
            //        if (newCapacity - minCapacity < 0)
            //            newCapacity = minCapacity; //newCapacity=10
            //        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);  //elementData的初始长度为10
            //    }
            //添加元素到集合尾部
            list.add(i);
        }


        //当添加第11个元素时，超出elementData的最大长度10，将进行第二次扩容【ensureExplicitCapacity方法中minCapacity=11，elementData.length=11， minCapacity-elementData.length > 0的条件满足，将进入 grow（）方法，对elementData的长度进行扩容】，保证元素能够加到集合的最末端。第二次扩容后的数组elementData的长度为15
        for (int i = 11; i <= 15; i++) {
            list.add(i);
        }

        
        //当添加第16个元素时，超出elementData的最大长度15，将进行第三次扩容，保证元素能够加到集合的最末端。第二次扩容后的数组elementData的长度为16
        for(int i=16;i<20;i++){
            list.add(i);
        }
    }
}

第二次扩容debug图

第三次扩容debug图

2.2参数构造ArrayList（int）

当创建ArrayList对象时，使用的是构造器函数ArrayList（int）时，扩容的思路与无参数构造函数中基本一致。

public class ArrayListPractice {

    public static void main(String[] args) {
        //有参数构造
        //    public ArrayList(int initialCapacity) {
        //        if (initialCapacity > 0) {
        //            this.elementData = new Object[initialCapacity]; //elementData的初始长度为指定长度的initialCapacity=8
        //        } else if (initialCapacity == 0) {
        //            this.elementData = EMPTY_ELEMENTDATA;
        //        } else {
        //            throw new IllegalArgumentException("Illegal Capacity: "+
        //                                               initialCapacity);
        //        }
        //    }
        ArrayList list = new ArrayList(8);

        for (int i = 1; i <= 8; i++) {
            //第一次添加元素
            //   public boolean add(E e) {
            //        ensureCapacityInternal(size + 1);
            //        elementData[size++] = e;
            //        return true;
            //    }

            //先进入是否需要扩容方法 minCapacity=1
            //  private static int calculateCapacity(Object[] elementData, int minCapacity) {
            //     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //     return Math.max(DEFAULT_CAPACITY, minCapacity);
            //   }
            //      return minCapacity; //1
            //   }

            //    private void ensureExplicitCapacity(int minCapacity) {
            //        modCount++; //记录当前集合被修改的次数
            //
            //        //1-8>0 条件不满足，即现在的elementData的长度可以存放添加进来的长度，不需要显示地进行elementData的扩容
            //        if (minCapacity - elementData.length > 0)
            //            grow(minCapacity);
            //    }

            //确认完不需要扩容是直接添加元素

            //当添加的元素超出elementData时，则扩容1.5倍。与无参数构造方法中扩容流程一致
            list.add(i);
        }
    }
}