ArrayLIst的自增长原理

构造方法

        三种

//如果已知容量， 则调用这个构造方法，可以获得指定容量的 数组

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

//构造空的数据即容量为0

 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

//构造 将一个集合中的所有元素添加到ArrayLst中，添加顺序是iterator返回的顺序

如果集合为空，则报空指针

 

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

 

 

ArrayLIst的自动增长

 

//添加元素，在添加元素会自动增长 具体增长情况 向下看：

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

 

首先会调用它：  作用为：//先判断 是否为空，如果为空，则挑选 默认的10 ，和传进来的参数比较大小，取最大值，然后执行ensrueExplicitiCapacity函数，具体看下面：

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

        ensureExplicitCapacity(minCapacity);
    }

 

//modCount 为结构性修改的次数 与  后面的迭代器有关

每次add 一次，或remove 或addAll 等等一次  modCount 都会+1

//然后判断 ，如果 参数的值 小于 当前数组的长度，则不做任何操作

如果 参数的值 大于当前数组长度，则执行grow操作

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

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

//grow 如果是第一此调用，则会扩展10 如果不是第一次调用，则 会增长一半 即是以前数组长度的2分之三.

如果增长后的长度大于int的（最大值-8）则执行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);
    }

 

 

 

即  判断 实际传过来的值是否大于int的（最大值-8），如果大于则用最大值，如果不大于则用int的（最大值-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;
    }

 

总的来说 ArrayList的 自动增长情况概述：

       当用无参构造方法情况下，第一次添加元素，则会调用

 ensureCapacityInternal 来判断是否第一次添加元素，如果是则默认增长的数值为10，然后执行ensureExplicitCapacity（不是第一次添加也会执行），该数组的结构性修改次数+1，然后判断 是否 需要数组的长度大于数据当前的长度，如果是则执行grow增长以前的一半（除了第一次增长，第一次增长就是默认10）（也要除了最后一次增长，意思是增长一半如果大于（最大值-8） 则另行执行另一个hugeCapacity函数，再判断你需要的长度 是否大于（最大值-8），如果大于则用int的最大值，如果不大于则用（最大值-8）），如果不是则不增长。

 

-------------------------第一次写，有点乱，见谅-----------------------------