public class ArrayList<E>{

    private static final int DEFAULT_CAPACITY = 10;//默认的容量是10

    private static final Object[] EMPTY_ELEMENTDATA = {};//长度为空的时候的数组，不可变的

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//默认长度的空数组

    transient Object[] elementData; //使用中的临时可变化的数组

    private int size;//数组中的个数

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    protected transient int modCount = 0;//

    public void ArrayList(int initialCapacity) {

        if (initialCapacity > 0) {

            this.elementData = new Object[initialCapacity];//新建一个

        } else if (initialCapacity == 0) {

            this.elementData = EMPTY_ELEMENTDATA;//默认是0,就把空数组复制给它

        } else {

            throw new IllegalArgumentException("Illegal Capacity: "+

                                               initialCapacity);//参数非法异常

        }

    }

    public void ArrayList() {

        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//空参的情况下默认0的数组赋值给它

    }

    /*增加*/

     public boolean add(E e) {

            ensureCapacityInternal(size + 1);  // Increments modCount!!

            elementData[size++] = e;

            return true;

        }

     /*检查是否需要扩容*/

        private void ensureCapacityInternal(int minCapacity) {

            //如果数组是空数组，最小容量赋值为默认10

            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

            }

            ensureExplicitCapacity(minCapacity);

        }

        /*确定扩容的大小

         * elementData是用来存储实际内容的数组。minExpand 是最小扩充容量。

         * DEFAULTCAPACITY_EMPTY_ELEMENTDATA共享的空数组实例用于默认大小的空实例。

         * 根据传入的最小需要容量minCapacity来和数组的容量长度对比，若minCapactity大于或等于数组容量，则需要进行扩容。

         *

         *

         * */

        private void ensureExplicitCapacity(int minCapacity) {

            modCount++; //AbstractList.class中的值 

            // overflow-conscious code 检测到溢出情况下的代码

            //如果最小所需容量>数组长度，就需要扩容

            if (minCapacity - elementData.length > 0)

                grow(minCapacity);

        }

        /*扩容操作*/

        private void grow(int minCapacity) {

            // overflow-conscious code

            int oldCapacity = elementData.length;

            int newCapacity = oldCapacity + (oldCapacity >> 1);//默认的相当于1.5倍？

            if (newCapacity - minCapacity < 0)

                newCapacity = minCapacity;//如果还是不够，就把需要的值赋值

            if (newCapacity - MAX_ARRAY_SIZE > 0)

                newCapacity = hugeCapacity(minCapacity);//判断newCapacity大容量情况，考虑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(); //如果minCapacity小于0 ，内存溢出

            return (minCapacity > MAX_ARRAY_SIZE) ?

                Integer.MAX_VALUE : //如果minCapacity也大于MAX_ARRAY_SIZE

                MAX_ARRAY_SIZE; //否则扩容到MAX_ARRAY_SIZE

        }

     /*   综上所述，ArrayList相当于在没指定initialCapacity时就是会使用延迟分配对象数组空间，

        当第一次插入元素时才分配10（默认）个对象空间。假如有20个数据需要添加，那么会分别在第一次的时候，

        将ArrayList的容量变为10 ,之后扩容会按照1.5倍增长。也就是当添加第11个数据的时候，

        Arraylist继续扩容变为10*1.5=15；当添加第16个数据时，继续扩容变为15 * 1.5 =22个

        在JDK1.7中，如果通过无参构造的话，初始数组容量为0，当真正对数组进行添加时，才真正分配容量。

      每次按照1.5倍（位运算）的比率通过copeOf的方式扩容。

            在JKD1.6中，如果通过无参构造的话，初始数组容量为10.每次通过copeOf的方式扩容后容量为原来的1.5倍加1。

        *

        */

}