ArrayList之add方法源码解析

@ArrayList之add方法源码解析

先看加入第一个元素的过程

成员变量

 private static final int DEFAULT_CAPACITY = 10;   //数组长度初始化是10
 private static final Object[] EMPTY_ELEMENTDATA = {};
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  //初始化指向地址
 transient Object[] elementData; // non-private to simplify nested class access
 private int size;   //存储的元素大小，size<DEFAULT_CAPACITY

构造方法

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;  //指向公共空数组
    }

add()方法

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 判断，并扩容
        elementData[size++] = e;
        return true;
    }

ensureCapacityInternal()方法

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  //第一次加入元素，此语句成立
            return Math.max(DEFAULT_CAPACITY, minCapacity);    //返回10
        }
        return minCapacity;
    }

  private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));  //minCapacity=1，参数为10
    }
private void ensureExplicitCapacity(int minCapacity) {  //传入10
        modCount++;  //调优参数，无视

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)  //数组为空，成立
            grow(minCapacity);    //此为扩容函数
    }

grow方法

private void grow(int minCapacity) {    //传入10
        // overflow-conscious code
        int oldCapacity = elementData.length;   //数组为空，值为0
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //还是0
        if (newCapacity - minCapacity < 0)    //成立，newCapacity=10
            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);   //开辟一个新数组，长度为10
    }

可见，插入第一个元素的时候，开辟了一个长度为10的数组。

插入第n个元素，1<n<=10

add()方法

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 参数n
        elementData[size++] = e;
        return true;
    }

ensureCapacityInternal()方法

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  //不是第一次加入元素，此语句不成立
            return Math.max(DEFAULT_CAPACITY, minCapacity);   
        }
        return minCapacity;
    }

  private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));  //minCapacity=n，返回参数为n
    }
private void ensureExplicitCapacity(int minCapacity) {  //传入n
        modCount++;  //调优参数，无视

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)  //数组长度为10，不成立
            grow(minCapacity);    //不扩容
    }

当插入不到容量时，正常处理即可

插入第11个元素

add()方法

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 传入11
        elementData[size++] = e;
        return true;
    }

ensureCapacityInternal()方法

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

  private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));  //minCapacity=11，参数为11
    }
private void ensureExplicitCapacity(int minCapacity) {  //传入10
        modCount++;  //调优参数，无视

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)  //11>10
            grow(minCapacity);    //此为扩容函数
    }

grow方法

private void grow(int minCapacity) {    //传入11
        // overflow-conscious code
        int oldCapacity = elementData.length;   //数组长度为10
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //扩充为原来的1.5倍
        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);   //开辟一个新数组，长度为15，复制原有数据
    }

可见，当插入数据越界，数组扩充为原来的1.5倍