ArrayList

其实在整个List体系中源码相对于其它类来说是比较简单的了。因为是作为第一篇，一切都还是简单点。
而ArrayList又是List体系中相对来说简单点的了。因此选择ArrayList作为第一篇。

分析

不管是分析什么源码，jdk源码也好，其它框架源码也好，最好是先写一个简单的Demo，然后debug，一步一步玩下走，这样能更好的帮助我们分析。

public static void main(String[] args) {
    // 默认初始化2
    List<String> list = new ArrayList<String>();
    list.add("java");
    list.add("c");
    list.add("c#"); // 此处会进行扩容 2 * 1.5 = 3 
}

构造函数

上面我创建了一个无参数的ArrayList。debug进去

public ArrayList() {
     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }

DEFAULTCAPACITY_EMPTY_ELEMENTDATA又是什么呢？

// 空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 底层存储结构
transient Object[] elementData; // non-private to simplify nested class access

从上面可以看出ArrayList底层是基于数组实现的，而在我们初始化的时候,随说做了一些处理，但是还是一个空数组，此时数组的长度还是为0。

add()

public boolean add(E e) {
    // 核心,第一次size为0
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 赋值并且size+1
    elementData[size++] = e;
    return true;
}

查看

private void ensureCapacityInternal(int minCapacity) {
    // 如果elementData 为null，则给一个默认值和minCapacity的最大值
      if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
          minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
      }
    
      ensureExplicitCapacity(minCapacity);
  }
// 判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
     modCount++;

     // overflow-conscious code
     // minCapacity > 数组容量  则需要扩容
     if (minCapacity - elementData.length > 0)
         grow(minCapacity);
 }


private void grow(int minCapacity) {
      // overflow-conscious code
      int oldCapacity = elementData.length;
      int newCapacity = oldCapacity + (oldCapacity >> 1);
      if (newCapacity - minCapacity < 0)
          newCapacity = minCapacity;
      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);
  }

上面的grow()方法则是扩容方法，默认情况下是旧的容量*1.5倍。如果新的容量小于minCapacity 的话，则新的容量重新赋值为minCapacity。

最后调用Arrays.copy(object[] original,int len)方法。

从上面流程我们可以知道。

• ArrayList的默认初始化长度不是在构造函数创建的，而是在第一次调用add()方法的时候给定默认值。
• ArrayList的扩容:①判断当前（minCapacity = size+1），②新的容量= 旧的容量*1.5。③如果新容量的大小 小于 minCapacity 则新的容量=minCapacity 。④，调用数组的copy()方法复制数据。

remove()

public E remove(int index) {
    // 检查remove的位置是否合法
    rangeCheck(index);

    modCount++;
    // 获取index位置的元素
    E oldValue = elementData(index);
    // 计算数组拷贝的长度
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 通知垃圾回收器可以回收(如果是对象的话)
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

从上面可知remove方法,也是调用System.arraycopy()方法完成数组的复制.它的思路是如下:
计算删除后index位的元素后,对应后面的元素往前覆盖,然后将最后一个在数组的元素赋null.注释也比较清楚了.

addAll()

public boolean addAll(Collection<? extends E> c) {
    // 将集合转为数组
    Object[] a = c.toArray();
    // 计算数组长度
    int numNew = a.length;
    // 判断是否会扩容
    ensureCapacityInternal(size + numNew);  // Increments modCount
    // 进行数组的拷贝
    System.arraycopy(a, 0, elementData, size, numNew);
    // 重新计算集合大小
    size += numNew;
    return numNew != 0;
}

public E get(int index) {
     rangeCheck(index);

     return elementData(index);
 }
 // 检出是否角标越界
private void rangeCheck(int index) {
    if (index >= size)
         throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
 }

总结

总的来说ArrayList的源码实现比较简单，这里也是分析了集合常用的方法。