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

List<Person> list = new ArrayList<>();

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

//如果是无参构造方法创建对象的话，ArrayList的初始化长度为10，这是一个静态常量
private static final int DEFAULT_CAPACITY = 10;//在这里可以看到我们不解的EMPTY_ELEMENTDATA实际上是一个空的对象数组private static final Object[] EMPTY_ELEMENTDATA = {};//保存ArrayList数据的对象数组缓冲区 空的ArrayList的elementData = EMPTY_ELEMENTDATA 这就是为什么说ArrayList底层是数组实现的了。elementData的初始容量为10，大小会根据ArrayList容量的增长而动态的增长。private transient Object[] elementData;
//集合的长度private int size;

 /*** Appends the specified element to the end of this list.*/
//增加元素到集合的最后
public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!//因为++运算符的特点 先使用后运算  这里实际上是//elementData[size] = e//size+1elementData[size++] = e;return true;
}

//初始长度是10，size默认值0，假定添加的是第一个元素，那么minCapacity=1 这是最小容量 如果小于这个容量就会报错
//如果底层数组就是默认数组，那么选一个大的值，就是10
private void ensureCapacityInternal(int minCapacity) {if (elementData == EMPTY_ELEMENTDATA) {minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}//调用另一个方法ensureExplicitCapacityensureExplicitCapacity(minCapacity);}private void ensureExplicitCapacity(int minCapacity) {//记录修改的次数modCount++;// overflow-conscious code//如果传过来的值大于初始长度 执行grow方法（参数为传过来的值）扩容if (minCapacity - elementData.length > 0)grow(minCapacity);}
//真正的扩容private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;//新的容量是在原有的容量基础上+50% 右移一位就是二分之一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://这里是重点 调用工具类Arrays的copyOf扩容elementData = Arrays.copyOf(elementData, newCapacity);}//Arrays
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {T[] copy = ((Object)newType == (Object)Object[].class)? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;
}

public void add(int index, E element) {//判断索引是否越界，如果越界就会抛出下标越界异常rangeCheckForAdd(index);
//扩容检查ensureCapacityInternal(size + 1);  // Increments modCount!!//将指定下标空出 具体作法就是index及其后的所有元素后移一位System.arraycopy(elementData, index, elementData, index + 1,size - index);//将要添加元素赋值到空出来的指定下标处elementData[index] = element;//长度加1size++;
}
//判断是否出现下标是否越界
private void rangeCheckForAdd(int index) {//如果下标超过了集合的尺寸 或者 小于0就是越界  if (index > size || index < 0)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

 /**移除list中指定位置的元素* Removes the element at the specified position in this list.所有后续元素左移 下标减1* Shifts any subsequent elements to the left (subtracts one from their* indices).*参数是要移除元素的下标* @param index the index of the element to be removed返回值是被移除的元素* @return the element that was removed from the list* @throws IndexOutOfBoundsException {@inheritDoc}*/
public E remove(int index) {//下标越界检查rangeCheck(index);
//修改次数统计modCount++;//获取这个下标上的值E oldValue = elementData(index);
//计算出需要移动的元素个数 （因为需要将后续元素左移一位 此处计算出来的是后续元素的位数）int numMoved = size - index - 1;//如果这个值大于0 说明后续有元素需要左移  是0说明被移除的对象就是最后一位元素if (numMoved > 0)//索引index只有的所有元素左移一位  覆盖掉index位置上的元素System.arraycopy(elementData, index+1, elementData, index,numMoved);// 将最后一个元素赋值为null  这样就可以被gc回收了elementData[--size] = null; // clear to let GC do its work
//返回index位置上的元素return oldValue;
}//移除特定元素
public boolean remove(Object o) {//如果元素是null 遍历数组移除第一个nullif (o == null) {for (int index = 0; index < size; index++)if (elementData[index] == null) {//遍历找到第一个null元素的下标 调用下标移除元素的方法fastRemove(index);return true;}} else {//找到元素对应的下标 调用下标移除元素的方法for (int index = 0; index < size; index++)if (o.equals(elementData[index])) {fastRemove(index);return true;}}return false;
}//按照下标移除元素
private void fastRemove(int index) {modCount++;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
}

private  writeObject(java.io.ObjectOutputStream s)throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();// Write out array lengths.writeInt(elementData.length);// Write out all elements in the proper order.
for (int i=0; i<size; i++)s.writeObject(elementData[i]);if (modCount != expectedModCount) {throw new ConcurrentModificationException();}
}

public synchronized boolean add(E e) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = e;return true;
}public synchronized E remove(int index) {modCount++;if (index >= elementCount)throw new ArrayIndexOutOfBoundsException(index);E oldValue = elementData(index);int numMoved = elementCount - index - 1;if (numMoved > 0)System.arraycopy(elementData, index+1, elementData, index,numMoved);elementData[--elementCount] = null; // Let gc do its workreturn oldValue;
}