ArrayList的add源码分析

1.如果是初始化ArrayList，初始容量为10。

2.如果大于10，会以1.5倍原来容量进行扩容。

public class ArrayListTest {
	public static void main(String[] args) throws Exception {
		ArrayList<String> arrayList = new ArrayList<String>();
		Class<? extends ArrayList> cls = arrayList.getClass();//获取字节码对象
		Field Field = cls.getDeclaredField("elementData");//获取私有属性
		Field.setAccessible(true);//暴力反射，设置私有可见
		for (int i = 0; i < 100; i++) {
			arrayList.add(i + "");
			Object[] object = (Object[]) Field.get(arrayList);//获取私有属性的值transient Object[] elementData;
			System.out.println(i + "数组的容量：" + object.length);
		}
	}
}
//运行结果：
//0数组的容量：10
//1数组的容量：10
//2数组的容量：10
//3数组的容量：10
//4数组的容量：10
//5数组的容量：10
//6数组的容量：10
//7数组的容量：10
//8数组的容量：10
//9数组的容量：10
//10数组的容量：15
//11数组的容量：15
//12数组的容量：15
//13数组的容量：15

ArrayList的构造方法：

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
//transient Object[] elementData; 用来保存元素的数组 默认为null
// private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 长度为空的数组

add方法：

public boolean add(E e) {   //E指元素类型
        ensureCapacityInternal(size + 1); //扩容  第十个元素时10+1=11
        elementData[size++] = e;
        return true;
    }
//private int size;//成员变量默认为0
--------------------------------------------------------------------------------------
private void ensureCapacityInternal(int minCapacity) {//1  //11
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
//方法calculateCapacity返回的结果为10      //第十个元素时返回结果为11
--------------------------------------------------------------------------------------
 private static int calculateCapacity(Object[] elementData, int minCapacity) {//(null,1)
      //第十个元素时(element不为null,11)
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//null==null
            return Math.max(DEFAULT_CAPACITY, minCapacity);//Math.max(10,1)
        }
        return minCapacity;
    }
//返回值为10
//private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//private static final int DEFAULT_CAPACITY = 10;
--------------------------------------------------------------------------------------
private void ensureExplicitCapacity(int minCapacity) {//10      //11
        modCount++;//记录数据结构发生变化的次数
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//10-0>0       //11-10>0
            grow(minCapacity);//grow(10)     //grow(11)
    }
--------------------------------------------------------------------------------------
private void grow(int minCapacity) {//10    //11
        // overflow-conscious code
        int oldCapacity = elementData.length; //0=0   //old=10
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量=老容量+老容量/2(1.5倍扩容)
        if (newCapacity - minCapacity < 0) //0-10=-10
            newCapacity = minCapacity;     //新容量=10
        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); 
    }
//elementData=10;第一次得到容量为10的数组
//第二次运行时 int oldCapacity=10;
//            int newCapacity=10+5=15; 
// elementData = Arrays.copyOf(elementData, newCapacity);
//Arrays中数组扩容的方法，底层调用
//       System.arraycopy(original, 0, copy, 0,
//                       Math.min(original.length, newLength));
//      return copy;
//  } 
//   public static native void arraycopy(Object src,  int  srcPos,
//                                      Object dest, int destPos,
//                                      int length);   
//private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 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;
    }