上次说到HashMap的源码，这次来聊聊ArrayList的源码。
ArrayList，顾名思义，底层是用Array即数组实现的。下面来看看实现细节。
1、ArrayList中的一些属性：
1 private static final int DEFAULT_CAPACITY = 10;// 默认初始化的容量
2 private static final Object[] EMPTY_ELEMENTDATA = {};// 空数组
3 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};// 空数组
4 transient Object[] elementData; // 存放元素的数组
5 private int size;// 数组中元素的个数
2、ArrayList的初始化：
1 public ArrayList() {
2 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
3 }
没传 initialCapacity 的时候，elementData 就是一个空数组。
1public ArrayList(int initialCapacity) {
2 if (initialCapacity > 0) {
3 this.elementData = new Object[initialCapacity];
4 } else if (initialCapacity == 0) {
5 this.elementData = EMPTY_ELEMENTDATA;
6 } else {
7 throw new IllegalArgumentException("Illegal Capacity: "+
8 initialCapacity);
9 }
10}
首先判断传入的 initialCapacity 是否大于0，大于0就new一个长度为 initialCapacity 的数组；如果等于0，那么 elementData 还是空数组；如果小于0，直接抛异常。
那么问题来了，空数组如何存元素？接下来看看 add 方法。
3、ArrayList的add方法：
1 public boolean add(E e) {
2 ensureCapacityInternal(size + 1); // Increments modCount!!
3 elementData[size++] = e;
4 return true;
5 }
调用add方法的时候，首先是调用了 ensureCapacityInternal 方法。这个方法接收一个int类型的参数，表示的是当前数组中的元素个数加1。现在是空数组，所以size就是0，也就说传入的是1。那么接下来看看 ensureCapacityInternal里面做了什么事。
1 private void ensureCapacityInternal(int minCapacity) {
2 ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
3 }
这个方法里面又调用了两个方法，一个calculateCapacity方法，然后将calculateCapacity方法的返回值作为参数再调用ensureExplicitCapacity方法。那么我们把她的衣服一件件的脱开，先看看calculateCapacity方法做了什么。
1 private static int calculateCapacity(Object[] elementData, int minCapacity) {
2 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
3 return Math.max(DEFAULT_CAPACITY, minCapacity);
4 }
5 return minCapacity;
6 }
它首先看看当前数组是否为空，如果为空，那么就返回DEFAULT_CAPACITY和minCapacity当中较大的一个。DEFAULT_CAPACITY就是10，minCapacity就是刚才传入的size + 1，也就是1，所以就返回10。然后将10作为参数传给ensureExplicitCapacity，看看里面发生了什么。
1 private void ensureExplicitCapacity(int minCapacity) {
2 modCount++;
3 if (minCapacity - elementData.length > 0)
4 grow(minCapacity);
5 }
这里有个变量自增了，这个先不管，看看下面的判断。现在这个minCapacity是刚才传入的10，数组的length是0，所以调用了grow方法。再去看看grow方法。
1 private void grow(int minCapacity) {
2 // overflow-conscious code
3 int oldCapacity = elementData.length;
4 int newCapacity = oldCapacity + (oldCapacity >> 1);
5 if (newCapacity - minCapacity < 0)
6 newCapacity = minCapacity;
7 if (newCapacity - MAX_ARRAY_SIZE > 0)
8 newCapacity = hugeCapacity(minCapacity);
9 // minCapacity is usually close to size, so this is a win:
10 elementData = Arrays.copyOf(elementData, newCapacity);
11 }
这里oldCapacity 是0，newCapacity的初始值是1.5倍的oldCapacity，所以也是0。接下来因为newCapacity减minCapacity是0减10，所以小于0，那么newCapacity就是10。最后调用Arrays.copyOf方法，初始化数组。Arrays.copyOf方法底层调用的System.arraycopy，这是一个本地方法。它会将一个旧数组中的数据拷贝到新数组中。
这既是初始化的过程，其实也是扩容的过程。add的时候，先将数组中的元素个数size 加 1传给ensureCapacityInternal方法，如果当前elementData为空，就是初始化，返回10，初始化一个大小为10的数组。如果elementData 不为空，就返回 size + 1 的值，将其传入ensureExplicitCapacity方法，判断size + 1的值减去当前数组的长度是否大于0。比如我现在elementData 的length为10，现在已经存了9个元素，即size + 1等于10，此时10减10是不大于的0，不执行grow方法。当存了10个元素的时候，10加1等于11，才会执行grow方法。也就是说，当数组满了才会执行扩容操作。扩容的时候，是扩容为当前数组容量的1.5倍，然后底层调用一个本地方法将旧数组数据转移到新数组。
总结：
