ArrayList底层源码分析

 2.1 无参构造
 //这个数组就是arrayList存数据的地方
   private static final Object[] elementData;
   //元素的个数，私有成员变量，默认为0
      private int size;

       public ArrayList() {
       //默认为空DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        }
    
     2.2 添加元素的方法
       public boolean add(E e) {
            ensureCapacityInternal(size + 1);  
            elementData[size++] = e;
            return true;
        }
       
         //保证容量的方法
         //minCapacity:是在添加的时候穿过来的当前元素个数+1
         //Object[] elementData;//arrayList存数据的数组
         private void ensureCapacityInternal(int minCapacity){//1
         ensureExplicitCapacity(calculateCapacity(elementData,minCapacity));
          }
       
//计算容量---如果是第一次就直接计算一个10容量给你，如果不是第一次，当前个数+1
        private static int calculateCapacity(Object[] elementData, int minCapacity) {
            //如果这数组为默认构造的空
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                //private static final int DEFAULT_CAPACITY = 10;默认初始化长度为10
                //取两个数中的最大值
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            }
            return minCapacity;
        }
    
         //保证一个确切容量的方法
          private void ensureExplicitCapacity(int minCapacity) {
            modCount++;//modCount = 0;模数，记录修改的次数
            
            // overflow-conscious code溢出考虑
              //10 - 0>0  我需要这么多容量，数组中容量不够，扩容
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
           }
         //扩容的方法--除第一次，以后会在缓存数组满了的时候扩容，每次扩到1.5倍
        private void grow(int minCapacity) {//1  11
            // overflow-conscious code
            int oldCapacity = elementData.length;//获取原来数组的长度 --0
            int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量变为1.5倍  -0
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;//判断新容量如果不满足需要的容量，就用需要的容量  10
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                // private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;数组指针需要空间
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);//扩容
        }
    
    带参构造：
         
        public ArrayList(int initialCapacity) {
            if (initialCapacity > 0) {
                //直接构造一个需要的容量给你
                this.elementData = new Object[initialCapacity];
            } else if (initialCapacity == 0) {
                //private static final Object[] EMPTY_ELEMENTDATA = {};
                this.elementData = EMPTY_ELEMENTDATA;
            } else {//异常
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            }
        }
    总结：
         ArrayList底层是一个Object[],无参构造的时候，先给了个空，当添加第一个元素默认将数组长度变为10，每次数组满了的时候，按照当前数组长度1.5倍进行扩容。