public boolean add(E e)的源码分析

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

          private static final long serialVersionUID = 8683452581122892189L;

          /**
           * 默认初始容量大小
           */
          private static final int DEFAULT_CAPACITY = 10;

          
		  /**
           * 空数组（用于空实例）。
           */
          private static final Object[] EMPTY_ELEMENTDATA = {};

          
		  // 空容量数组，长度为0
          private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

          
		  // 保存ArrayList数据的数组
          private transient Object[] elementData;


          
		  // 无参构造方法
          public ArrayList() {
              this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
          }


       
          
		  /**
           *  带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
           */
           public ArrayList(int initialCapacity) {
              if (initialCapacity > 0) {
                  // 如果传入的参数大于0，创建initialCapacity大小的数组
                  this.elementData = new Object[initialCapacity];
              } else if (initialCapacity == 0) {
                   // 如果传入的参数等于0，创建空数组
                  this.elementData = EMPTY_ELEMENTDATA;
              } else {
                  throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
              }
          }

         
		  /**
		   *  添加方法
		   */
		  public boolean add(E e) {
			  ensureCapacityInternal(size + 1);  // 扩容方法
			  elementData[size++] = e;
			  return true;
		  }



          /**
           * 在此列表中的指定位置插入指定的元素。
           * 先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
           * 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
           */
          public void add(int index, E element) {
		  
              rangeCheckForAdd(index);

              ensureCapacityInternal(size + 1);  // Increments modCount!!
			  
              //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己
              System.arraycopy(elementData, index, elementData, index + 1,size - index);
			  
              elementData[index] = element;
			  
              size++;
          }
}

// 确保内部容量达到指定的最小容量。
private void ensureCapacityInternal(int minCapacity) {
	
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {    // 空列表首次添加：minCapacity 取 Math.max(10, 1) = 10，而数组长度为 0，触发扩容到 10
	  minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); 
	}
	
	ensureExplicitCapacity(minCapacity); 
}

//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {

	  // 记录集合被修改的次数，防止产生多线程并发问题
	  modCount++;

	  // 容器的最小容量 - 当前容器实际容量  > 0
	  if (minCapacity - elementData.length > 0)        // 满列表继续添加：当前 size = elementData.length = 10，调用 add 时 minCapacity = 11 > 10，触发扩容
		  //调用grow方法进行扩容，调用此方法代表已经开始扩容了
		  grow(minCapacity);
}

/**
 * ArrayList扩容的核心方法。
 */
private void grow(int minCapacity) {

    // oldCapacity为旧容量，newCapacity为新容量
    int oldCapacity = elementData.length;
    
    
    //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
    //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
    int newCapacity = oldCapacity + (oldCapacity >> 1);

    
    //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，否则取新容量
    if (newCapacity - minCapacity < 0)
  	  newCapacity = minCapacity;
  	
    
    //再检查新容量是否超出了ArrayList所定义的最大容量，
    //若超出了，则调用 hugeCapacity()来比较minCapacity 和 MAX_ARRAY_SIZE，
    //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为 Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE。
    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);
}

// 比较minCapacity和 MAX_ARRAY_SIZE
private static int hugeCapacity(int minCapacity) {
          if (minCapacity < 0) // overflow
              throw new OutOfMemoryError();
          return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}        

// System.arraycopy() 方法
/**
 * 复制数组
 * @param src 源数组
 * @param srcPos 源数组中的起始位置
 * @param dest 目标数组
 * @param destPos 目标数组中的起始位置
 * @param length 要复制的数组元素的数量
 */
public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);


// Arrays.copyOf()方法
public static int[] copyOf(int[] original, int newLength) {

	    // 申请一个新的数组
		int[] copy = new int[newLength];
  
		// 调用System.arraycopy,将源数组中的数据进行拷贝,并返回新的数组
		System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
		
		return copy;
}

总结分析：

1、add()方法，集合ArrayList底层使用数组实现，对象刚创建的时候底层维护一个空数组，在添加数据时，数组默认长度设置为 10

2、当插入数据 10 长度不够，这时候以【1.5倍】的形式进行扩容