基于JDK 1.8.0.211
个人观点，水平低下，谨慎阅读
要阅读ArrayList源码，我这里打算先看一遍正常的使用流程，然后再去分析一下别的函数
此外，先看一眼继承树
首先是这句话
ArrayList<Integer> list = new ArrayList<>();
进入构造函数之后，你会发现构造函数出奇的简单
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
其中elementData 和 DEFAULTCAPACITY_EMPTY_ELEMENTDATA都是在ArrayList类中定义的
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
据我观察，ArrayList类中没有静态代码块，而且DEFAULTCAPACITY_EMPTY_ELEMENTDATA 已经被final修饰，所以这句话显然是说，将elementData赋值为一个空的Object数组
根据参数的命名和这里的操作，我们可以猜测，elementData就是ArrayList中存储数据的地方
看到这里，相信你一定和我一样，有两个疑问。
1.为什么elementData使用transient 修饰
众所周知，这个修饰符使得变量不能被序列化，也就是说难道ArrayList不能将数据序列化吗？
2.为什么这两个成员变量都没有使用泛型？
那我指定的类型信息在哪里被使用了呢？
目前，我们只能继续向下阅读了
让我们执行这句话
list.add(45);
add方法也很简洁
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
第一个函数是ensureCapacityInternal，字面意思是确认内部空间足够
没有返回任何值，那么基本可以确认所谓的动态扩容就在这在函数内进行了
其后，在elementData中加入了我们传入的参数
这里参数用到了泛型，于是编译器便会检测传入的数据类型是否正确（难道这就是泛型的作用吗？）
size可以猜到，就是在ArrayList的数据个数，而且可以猜到size()函数要怎么写了
返回ture表示插入成功，从我现在的知识看，这个返回是没有意义的，于是猜测是版本遗留问题
我们进入ensureCapacityInternal看一下先
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
刚刚传入的参数是size+1，就是如果还要插入一个元素，需要的最小空间是多少
这里有一个函数套函数，先看内层函数calculateCapacity
看函数名意思是计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
这里的意思是，如果是第一次添加元素（别忘了DEFAULTCAPACITY_EMPTY_ELEMENTDATA的声明哦），就返回传入参数与默认参数的最大值
既然这里取了最大值，那就说明有可能一次添加多个元素哦！
private static final int DEFAULT_CAPACITY = 10;
现在可以回头来看外层函数ensureExplicitCapacity了，字面意思确认明确容量
传入的参数是指需要的容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
首先，modCount是一个什么东西呢，我们可以发现，源码中有注释
大致意思是说，这个变量用来记录数据被修改了多少次，如果多线程中有迭代器访问ArrayList的同时，有一个另外线程修改了数据，可以快速通过它抛出异常
然后我们来看grow函数
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);
}
废话不多说，新的容量被设定为旧容量的1.5倍，要是还不够，那需要多少就给多少
如果新的容量已经比MAX_ARRAY_SIZE （Integer.MAX_VALUE -8）还要大了，那就看设定为Integer.MAX_VALUE还是MAX_ARRAY_SIZE
如果新容量是负数（溢出），则抛出异常
到这里容量便扩展完成
以上未免说得太仔细了，我没有时间这么干了，接下来我们速推,加上中文注释应该很好理解了
方法：
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;
size++;
}
//添加另外一个集合的所有元素
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
//这里就是刚刚说的一次增加多个
ensureCapacityInternal(size + numNew); // Increments modCount
//将a中的元素赋值给size
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
//添加另外一个集合的所有元素，不过这次不是插在最后，而是在index位置
public boolean addAll(int index, Collection<? extends E> c) {
//判断是否越界
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
//将原有index(包括)后面的元素挪动numMoved个单位
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
//为什么在这里返回呢，早一点返回不是更优吗
//难道什么都不加，也要通知modCount吗？
return numNew != 0;
}
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
//注意，这里并没有改变elementData.length
//所以并不会优化内存
//看一眼ensureExplicitCapacity()方法，你就知道，在minCapacity>elementData.length时，grow()不会被执行
size = 0;
}
注意，ArrayList实现了Cloneable接口
public Object clone() {
try {
//为什么要用通配符呢？直接写上E不好吗
ArrayList<?> v = (ArrayList<?>) super.clone();
//复制数组
//请注意这里的方法 Arrays.copyOf()也是一个浅拷贝方法
//如果随后修改了其中的某个值，也会改变当前ArrayList的值
//但是我们目前为止还没有遇到过修改ArrayList中值的方法
//光是引用位置的变化(add等)不会影响原来ArrayList中的值
v.elementData = Arrays.copyOf(elementData, size);
//定义在父类中的modCount
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
//寻找o的下标
//无脑遍历
//而且可以看出来只返回第一个o的下标
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
//判断o是否存在，因为如果没找到，indexof会返回-1
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
containsAll定义在父类AbstractCollection中，判断当前ArrayList中是否包含了参数中的所有对象
注意AbstractCollection也定义了contains方法，与ArrayList重写的方法，唯一的不同就是，AbstractCollection使用了迭代器，而不是for
//无脑遍历
public boolean containsAll(Collection<?> c) {
for (Object e : c)
if (!contains(e))
return false;
return true;
}
get这个方法与clone方法结合在一起看非常危险
试验了一下，在clone中的ArrayList中修改这个元素信息，果然影响了原来的ArrayList元素
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
由此可见
Arraylist的clone方法是比较危险的
私有方法，没有返回值，没有检查边界
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
}
定义在接口迭代器里的默认方法，这里是重写的代码
@Override
//消费型函数试接口，或许这就是JDK8的新特性吧
public void forEach(Consumer<? super E> action) {
//要求action不等于null，否则抛出异常
Objects.requireNonNull(action);
//看呐，modCount开始发挥作用了
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int size = this.size;
//在遍历途中观察有没有其他线程修改ArrayList,一旦有立刻跳出循环
for (int i=0; modCount == expectedModCount && i < size; i++) {
//accept是消费型函数式接口的唯一一个方法，不清楚的可以先了解一下函数式编程哦
action.accept(elementData[i]);
}
//在这里抛出异常
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
一句话函数
public boolean isEmpty() {
return size == 0;
}
返回一个迭代器
注意迭代器是内部类，实现了Iterator接口
内部类我们稍后聊
public Iterator<E> iterator() {
return new Itr();
}
这个也一样，不过ListItr是Itr的子类
public ListIterator<E> listIterator() {
return new ListItr(0);
}
倒着走的indexof，节约篇幅，不贴代码了
public int lastIndexOf(Object o)
移除某个位置的元素
也就是删一个挪一堆
注意，elementData.length并没有因此改变
感觉不用贴代码了吧(越来越懒了)
public E remove(int index)；
//只删第一个，其实就是先找到第一次出现的位置，在调用私有方法fastRemove(index)将其删除
public boolean remove(Object o)；
//这个方法调用了下面的batchRemove那个方法
public boolean removeAll(Collection<?> c) ；
删除一部分
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
//如果当前这个元素不在c中(RemoveAll传进来的是false,这里就此分析)
//就将其直接复制到数组开头
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
// c.contains()搞不好会抛出异常
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
//如果modCount只是用在了判断有没有被修改过，那么++不就好了吗？
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
果然，retainall就是刚好和removeall相反，调用batchRemove的时候传入了true
将ArrayList变成数组。和clone一样，浅复制
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
这就是大部分常用函数了
值得注意的是，ArrayList中有几个内部类，他们有的是迭代器，在这里不多说，还有一个是sublist，返回一个ArrayList的子list，其实就是ArrayList的一段映射，但是只实现了List接口内的相关方法