前言
很久之前写过一篇有关HashMap的文章：啃碎JDK源码(四)：HashMap，反响不错。本来手后面是想写篇文章来介绍ArrayList，后来事情多就忘了，今天就来好好聊聊ArrayList。
正文
ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。
ArrayList相比HashMap来说就比较简单了，先来看看实现了哪些接口：
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable{
//默认容量大小
private static final int DEFAULT_CAPACITY = 10;
//指定ArrayList容量为0时返回该数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//当没有指定ArrayList容量时返回该数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//保存添加到ArrayList中的元素（ArrayList的底层其实就是一个数组）
transient Object[] elementData;
//ArrayList中元素数量
private int size;
.....
} 从上面的源码我们可以提取出下面几个关键信息：
ArrayList底层使用一个Object类型的数组来保存数据ArrayList默认大小为10
可以看到ArrayList底层是使用一个数组elementData来保存数据的，因此也被称为动态数组。值得注意的是用了elementData用了transient修饰。
transient表示elementData无法被序列化，为什么要这么设置呢？
因为elementData里面不是所有的元素都有数据，因为容量的问题，elementData里面有一些元素是空的，这种是没有必要序列化的。
ArrayList的序列化和反序列化依赖writeObject和readObject方法来实现。可以避免序列化空的元素。
接下来我们从常用构造函数入手：
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
}
}上面两个构造函数比较简单，就是给对数组做初始化，这里不再细说。
ArrayList还有一个构造函数：
public ArrayList(Collection c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
//如果传入的c长度为0，则替换成空数组
elementData = EMPTY_ELEMENTDATA;
}
}首先调用toArray()返回一个数组，因为不一定会返回Object类型，所以需要判断一下类型，如果类型不同则调用Arrays.copyOf方法，我们来看看源码：
/*
* 复制数组，并转型为指定类型
* original——>原数组 newLength——>要复制的长度 newType——>新类型
*/
public static T[] copyOf(U[] original, int newLength, Class newType) {
//判断是否是Object类型
T[] copy = ((Object)newType == (Object)Object[].class)//（这里不加(Object)强转编译器无法通过）
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
//getComponentType()——>本地方法，返回数组内的元素类型，不是数组时，返回null
//Array.newInstance——>创建一个类型与newType一样，长度为newLength的数组
System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));//截断数组
return copy;
} 从注释也可以看出该方法可以复制数组，并转型为指定类型，之前的啃碎JDK源码\(一\)：String已经对System.arraycopy做了介绍，感兴趣的小伙伴可以去看看，这里不再重述。
添加元素
接下来是一个比较核心的方法add
/*添加元素到集合中*/
public boolean add(E e) {
//判断ArrayList是否需要扩容
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
/*判断是否需要扩容——> minCapacity是集合需要的最小容量*/
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/*返回添加元素后的容量大小*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//首次添加元素时，返回 minCapacity > 10 ? minCapacity : 10 （首次可能使用addAll方法添加大量元素）
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
/*判断是否需要扩容*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//modCount是继承自AbstractList的变量，用来表示集合被修改的次数
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/*扩容*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容为原来的1.5倍
if (newCapacity - minCapacity < 0)//如果扩容后还是小于最小容量，则设置minCapacity为容量大小
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
newCapacity = hugeCapacity(minCapacity);
//调用Arrays.copyOf生成新数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}到目前为止，我们就可以知道add(E e)的基本实现了：
添加元素时，首先去检查一下数组的容量是否足够，如果不够则扩容到原来的1.5倍
扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity，最后调用Arrays.copyOf(elementData, newCapacity)方法生成新的数组。
获取、设置元素
下面看看get和set方法：
/*
* 获取index索引对象
*/
public E get(int index) {
rangeCheck(index);//参数校验
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
/*
* 设置index索引对象
*/
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}两个方法都比较简单，这里不再展开细说。
删除元素
接下来看一下ArrayList如何删除元素：
/*
* 删除index索引对象
*/
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);
elementData[--size] = null; //设为null让JVM回收
return oldValue;//返回旧数据
}做个简单总结
- 计算出需要左移的个数后，使用
System.arraycopy方法截断生成新数组 - 删除元素后将最后一位设为
null便于JVM回收
还有另外一个remove(Object o)方法：
/*
* 删除给定Object对象
*/
public boolean remove(Object o) {
if (o == null) {//删除null对象-->ArrayList可以存放null
for (int index = 0; index < size; index++)
if (elementData[index] == 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++;//修改次数+1
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
}这部分源码比较简单，就是遍历比较然后删除。值得注意的是ArrayList可以存null值，因为需要对null参数做额外处理。
注意：调用remove删除元素时不会减少容量，若希望减少容量则调用trimToSize(),比较简单，下面直接贴上源码：
/*
* 修改数组尺寸
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}最后再来介绍几个平时用的比较多的方法：
我们平开发也会经常使用contains方法来判断是否包含某个元素，下面看下是如何实现的：
/*
* 判断集合中是否包含某元素
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}可以看到直接使用indexOf来判断，和之前String源码比较类似，直接来看看代码：
/*
* 返回指定元素第一次出现的位置（返回-1表示没有此元素）
* lastIndexOf——>同理（其实就是从后向前遍历）
*/
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;
}其实就是遍历依次比较，相等则返回下标。
总结
看完是不是觉得相比HashMap来说ArrayList的源码还是比较能看懂的，当然我们这里只列出了一些比较常用的方法，像ArrayList其实还有一些Itr等内部类，其实就是我们平时用的迭代器，如果对这些感兴趣的小伙伴可以自己去研究一下。