一、前言
一直都只是会用ArrayList，对于ArrayList的理解都比较简单。正好借此机会也把自己观看源码的一些理解写出来。方便自己以后回顾。使用的版本是JDK1.8。
二、ArrayList特点
随机访问速度快，插入和移除性能较差(数组的特点)，支持null元素，有顺序，元素可以重复，线程不安全。
三、数组扩容所使用到的API
1、直接将数组容量扩容至一个固定值。生成一个新的数组
Object[] objs = {1, 2};
System.out.println(objs.length);
Object[] objects = Arrays.copyOf(objs, 10);
System.out.println(objects.length);
2、将原数组从起始位置开始到复制的长度，替换目标数组从目标起始位置到替换的长度。
//原始数组
int [] arr={1,2,3,4,5,6,7,8};
for (int i : arr) {
System.out.print(i+",");
}
System.out.println();
//目标数组
int[] arr1=new int[11];
arr1[0]=1;
arr1[1]=2;
arr1[2]=3;
//参数 原数组 ，起始位置 ，目标数组 ，目标的起始位置 ， 复制的长度 这是一个本地方法
System.arraycopy(arr,0,arr1,3,8);
//从起始位置复制，替换目标起始位置，需要复制的长度
for (int i : arr1) {
System.out.print(i+",");
}
结论：从arr数组0索引开始，copy到arr1数组从索引为3的开始。长度为8。
四、ArrayList的继承实现关系
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
- ArrayList实现了List接口是一个数组队列拥有了List基本的增删改查功能
- ArrayList实现了RandomAccess接口拥有随机读写的功能
- ArrayList实现了Cloneable接口可以被克隆
- ArrayList实现了Serializable接口并重写了序列化和反序列化方法，使得ArrayList可以拥有更好的序列化的性能
五、ArrayList类属性
//序列版本号
private static final long serialVersionUID = 8683452581122892189L;
//默认数组容量
private static final int DEFAULT_CAPACITY = 10;
//当指定数组的容量为0时使用这个常量赋值
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空参构造函数时使用这个常量赋值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//真正存放数据的对象数组，transient标识不被序列化
transient Object[] elementData;
//数组中的真实元素个数，该值小于或等于elementData.length
private int size;
// 最大数组容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//记录修改次数 继承于AbstractList
protected transient int modCount = 0;
六、ArrayList构造方法
//初始化设置数组集合长度
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];//初始长度大于0，就直接初始化数组容量
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;//默认复制一个空数组
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);//报错
}
}
public ArrayList() {
//默认空数组 JDK1.7之后初始化的时候不指定大小，那么集合初始大小为0
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();//转化为数组
if ((size = elementData.length) != 0) {//非空集合
if (elementData.getClass() != Object[].class)//是否转化为Object类型数组
elementData = Arrays.copyOf(elementData, size, Object[].class);//不为Object类型数组就进行复制
} else {
this.elementData = EMPTY_ELEMENTDATA;//空集合，初始为空数组
}
}
七、add方法
public boolean add(E e) {
ensureCapacityInternal(size + 1); //真实数组元素加1 调用ensureCapacityInternal方法
elementData[size++] = e; //进行处理之后，将值复制到索引为size的位置上
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//判断
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//空数组，返回两个值最大的一个
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
//不是空数组直接返回minCapacity
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //修改统计数+1
// 判断数组真实元素个数加1后的长度与当前数组长度大小关系，如果小于0，返回，如果大于0就调用grow()方法
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
//原始数组的长度
int oldCapacity = elementData.length;
// 新增数组容量大小 (oldCapacity >> 1)=oldCapacity/2
int newCapacity = oldCapacity + (oldCapacity >> 1);
//这个地方有一个面试题，如果初始数组的长度1，增加的元素超过1个，那么上面计算的新数组大小也是为1的。这个判断就是如果新数组小于minCapacity，最少保证newCapacity=minCapacity
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
//最多不能超过最大容量
newCapacity = hugeCapacity(minCapacity);
//复制数组从新赋值
elementData = Arrays.copyOf(elementData, newCapacity);
}
public void add(int index, E element) {
rangeCheckForAdd(index);//索引校验
//这里和上面add（）处理的差不多 扩容数组
ensureCapacityInternal(size + 1);
//这个地方和上面最开始说的那种copy例子差不多，从elementData数组的index索引位置开始，copy到elementData数组索引位置为index+1。长度为size-index
//说白了就是将存在index索引位置的值一直到size-index中间所有的值。替换index-1索引位置一直到size-index的值
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;//根据索引复制
size++;
}
private void rangeCheckForAdd(int index) {
//超过数组实际长度报错
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
结论：从源码上看，两个方法大致相同，最主要的差别是System.arraycopy(elementData, index, elementData, index + 1, size - index)，从index位置开始以及之后的数据，整体拷贝到index+1开始的位置，然后再把新加入的数据放在index这个位置，而之前的数据不需要移动。（这些动作比较消耗性能）
八、get方法
public E get(int index) {
rangeCheck(index);//校验索引是否越界
//根据索引取值
return elementData(index);
}
九、remove方法
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
//计算删除元素后面的长度
int numMoved = size - index - 1;
if (numMoved > 0)
//还是一样的操作，先替换数组
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//因为数组已经替换了，把size-1的索引位置的元素赋值为null,方便GC回收
elementData[--size] = null;
return oldValue;
}
public boolean remove(Object o) {
if (o == null) {
// 为null的时候遍历删除第一个位null的值
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
//不为null的时候通过equals判断删除
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;
}
结论：删除其实还是使用的是java.lang.System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)，也是比较消耗性能的
十、set方法
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
结论：修改没什么好说的，索引校验，然后获取之前索引的值，替换、返回。
总结：基于数组实现的List在随机访问和遍历的效率比较高，但是往指定位置加入元素或者删除指定位置的元素效率比较低。jdk1.7之前默认初始长度为10，jdk1.8之后初始长度为0，第一次add的时候如果没有指定长度默认为10。如果数组的实际容量 + 1 大于 数组的存储容量的时候，就开始扩容，每次扩1.5 倍。