public class ArrayList<E> {
     //默认的容量
    private static final int DEFAULT_CAPACITY = 10;
    //长度为0的空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //默认容量为空的数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //集合存元素的数组
    transient Object[] elementData;
    //集合的长度
    private int size;

  /**
  *默认构造函数，使用初始容量10构造一个空列表(无参数构      造)
  */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

 /**
  *带初始容量参数的构造函数。（用户自己指定容量）
  */
      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);
              }    
          }

    /**
     *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
     *如果指定的集合为null，throws NullPointerException。 
     */
      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;
         }
     }


      //将添加的数据传入给e，追加到列表末尾
      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);
        }
        return minCapacity;
    }


     private void ensureCapacityInternal(int minCapacity) {
        //将if中计算出来的容量传递给下一个方法,继续校验
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }


 //判断是否需要扩容
      private void ensureExplicitCapacity(int minCapacity) {
       //实际修改集合次数++ (在扩容的过程中没用,主要是用于迭代器中)
       modCount++; 
      //判断最小容量 - 数组长度是否大于 0
       if (minCapacity - elementData.length > 0) 
      //将第一次计算出来的容量传递给 核心扩容方法 
      grow(minCapacity); 
  }


/**
*核心扩容方法
*/
      private void grow(int minCapacity) {
       //记录数组的实际长度,此时由于木有存储元素,长度为0
        int oldCapacity = elementData.length;
      //核心扩容算法 原容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
      //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //判断新容量-最大数组大小 是否>0,如果条件满足就计算出一个超大容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //// 调用数组工具类方法,创建一个新数组,将新数组的地址赋值给elementData
        elementData = Arrays.copyOf(elementData, newCapacity);
    }


}