ArrayList扩容方式的理解

目录

ArrayList基于Object[]数组实现【Object[] elementData】

成员变量

构造方法

ArrayList类中一共提供了3个构造方法用于初始化ArrayList

ArrayList扩容

一、当数组容量默认为空数组时，第1次添加元素时，数组会扩容为10

二、当数组容量不足时，按照原容量的1.5倍进行扩容增长

三、数组的容量在Integer.MAX_VALUE-8至Integer.MAX_VALUE之间,返回容量值，若超出Integer.MAX_VALUE,容量值会溢出，值会变为负数，那么抛出OutOfMemoryError错误

add（）、grow（）及其相关调用的源代码

---

ArrayList基于Object[]数组实现【Object[] elementData】

成员变量

    //序列化版本id
    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 = {};

    //用于存放元素的数组
    transient Object[] elementData; 

    //elementData数组中元素的个数
    private int size;
    
    //最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

构造方法

ArrayList类中一共提供了3个构造方法用于初始化ArrayList

1.无参构造

     public ArrayList() {
        //将存储数据的elementData数组初始化为一个空数组{}
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//{}
    }
2.有参构造【参数：初始容量值】

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

3.有参构造【参数：Collection集合】

     public ArrayList(Collection<? extends E> c) {
        //将集合转换为数组赋值给elementData
        elementData = c.toArray();
        //将elementData的长度赋值给size并判断是否!=0
        if ((size = elementData.length) != 0) {
            //判断elementData是否为Object[]类型
            if (elementData.getClass() != Object[].class)
                //创建一个size大小的Object[],让elementData指向
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //若elementData的长度为0，则初始化为一个空数组{}
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

ArrayList扩容

当ArrayList中所要存入的元素个数超过初始的elementData数组的长度时，就需要进行扩容

一、当数组容量默认为空数组时，第1次添加元素时，数组会扩容为10

//此时elementData={}
List<Integer>list = new ArrayList<>();
//调用ArrayList中的add()
list.add(2);

(1)调用add(),此时size+1=1

(2)调用ensureCapacityInternal(1)

        1) 调用calculateCapacity(elementData, 1)，

     当前elementData为{}，返回Math.max(DEFAULT_CAPACITY, minCapacity)；//max(10,1)

        2)调用ensureExplicitCapacity(10),即minCapacity=10，elementData.length=0

     minCapacity - elementData.length > 0，转向3）

        3)调用grow(minCapacity)， int oldCapacity = 0,newCapacity按oldCapacity的1.5倍扩容
     若newCapacity【0】 - minCapacity 【10】< 0，newCapacity = minCapacity;

     //把旧数组拷贝到扩容后的新组数中
    elementData = Arrays.copyOf(elementData, newCapacity);

(3)完成扩容后，回到add()方法中将元素2添加到elementData数组末尾，并让size++

数组容量由0——>10

二、当数组容量不足时，按照原容量的1.5倍进行扩容增长

//此时elementData={}
List<Integer>list = new ArrayList<>();
//调用ArrayList中的add()
list.add(9);    list.add(2);    list.add(3);    list.add(5);
list.add(5);    list.add(0);    list.add(10);   list.add(7);
list.add(7);
//添加第10个元素
list.add(17);
//添加第11个元素
list.add(21);

        1、若此时list中已存在9个元素，我们add(17)第10个元素时

调用ensureCapacityInternal（10），计算出添加元素时的最小容量，返回最小容量10，

继续判断此次添加元素是否需要扩容

调用ensureExplicitCapacity(10)判断此次添加元素是否需要扩容,10>10不成立不需要扩容，故第10个元素添加成功，size++，size=10

        2、继续add（21）第11个元素时，前面逻辑与添加第10个元素一致返回最小容量11，但调用ensureExplicitCapacity(11)，11>10成立，此次添加元素需要进行扩容，调用grow(11)

原数组容量=10，新数组容量=原数组*1.5=15，把旧数组拷贝到扩容后的新数组中

添加第11个元素，size++,size=11。数组容量由10——>15。

        3、当添加第15个元素时，逻辑同理，容量由15——>22。

往下以此类推

三、数组的容量在Integer.MAX_VALUE-8至Integer.MAX_VALUE之间,返回容量值，若超出Integer.MAX_VALUE,容量值会溢出，值会变为负数，那么抛出OutOfMemoryError错误

//处理大容量【容量>Integer.MAX_VALUE-8】的方法
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

add（）、grow（）及其相关调用的源代码

    //add()源代码及调用相关代码如下：
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  
        elementData[size++] = e;
        return true;
    }
    //确保添加元素的时候，最小容量是 minCapacity
    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++;
        
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //扩容方法
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }