ArrayList 是 java 中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口、RandomAccess 接口、Cloneable 接口、Serializable 接口。底层基于数组实现容量大小动态变化、支持快速访问、复制、序列化、允许 null 值的存在。
1. 成员变量
1.1. 默认容量 DEFAULT_CAPACITY
默认初始容量大小为 10。
/**
* 默认初始容量。
*/
private static final int DEFAULT_CAPACITY = 10;
1.2. 空元素数据 EMPTY_ELEMENTDATA
用于构造函数里面的。
/**
* 用于空实例的共享空数组实例。
*/
private static final Object[] EMPTY_ELEMENTDATA = {
};
1.3. 默认容量空元素数据 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
用于构造函数里面的。
/**
* 第一次添加元素时知道该 elementData 从空的构造函数还是有参构造函数被初始化的。
* 以便确认如何扩容。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
};
1.4. 元素数据 elementData
ArrayList 底层是基于数组来实现容量大小动态变化的。
/**
* 存储ArrayList元素的数组缓冲区。
* ArrayList的容量是此数组缓冲区的长度。
* 当添加第一个元素时，
* 任何elementData==DEFAULTCAPACITY_EMPTY_ELEMENTDATA的
* 空ArrayList都将扩展为DEFAULT_CAPACITY 。
*/
transient Object[] elementData; // 非私有以简化嵌套类访问
1.5. 容量 size
size 是指 elementData 中实际有多少个元素，而 elementData.length 为集合容量，表示最多可以容纳多少个元素。
/**
* ArrayList的大小（它包含的元素数）。
* @serial
*/
private int size;
2. 构造函数
2.1. 无参构造函数
当使用无参构造函数时是把 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 赋值给 elementData。
/**
* 构造一个初始容量为10的空列表。
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
构造函数了只是给 elementData 赋值了一个空的数组，其实是在第一次添加元素时容量扩大至 10 的。
2.2. 构造一个初始容量大小为 initialCapacity 的 ArrayList
当 initialCapacity 为零时则是把 EMPTY_ELEMENTDATA 赋值给 elementData， 当 initialCapacity 大于零时初始化一个大小为 initialCapacity 的 object 数组并赋值给 elementData。
/**
* 构造具有指定初始容量的空列表。
*
* @param initialCapacity列表的初始容量
* @throws 如果指定的初始容量为负，则抛出IllegalArgumentException异常
*/
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);
}
}
2.3. 指定 Collection 来构造 ArrayList 的构造函数
将 Collection 转化为数组并赋值给 elementData，把 elementData 中元素的个数赋值给 size。 如果 size 不为零，则判断 elementData 的 class 类型是否为 Object[]，不是的话则做一次转换。 如果 size 为零，则把 EMPTY_ELEMENTDATA 赋值给 elementData，相当于new ArrayList(0)。
/**
* 按照集合迭代器返回元素的顺序，构造一个包含指定集合元素的列表。
* @param 要将 C 的元素放入此列表的集合
* @throws 如果指定的集合为null，则会抛出NullPointerException
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
3. 私有方法
先了解一下在ArrayList中会复用的方法及其作用
3.1. ensureCapacityInternal 方法
ensureCapacityInternal 方法 方法名翻译过来就是 确定容量，主要作用就是判断ArrayList是否需要扩容
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
ensureCapacityInternal 中调用了 ensureExplicitCapacity 方法和 calculateCapacity 方法
3.2. ensureExplicitCapacity 方法
ensureExplicitCapacity方法 方法名翻译过来就是 确定扩容方式，主要作用就是判断ArrayList扩容的方法。
ensureExplicitCapacity方法 中主要是调用的grow 方法，如果需要扩容modCount自增，这个参数是指当前列表的结构被修改的次数，判断当前数据量是否大于数组的长度，如果是，进行扩容。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
3.3. calculateCapacity 方法
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 并不是 EMPTY_ELEMENTDATA，不过并无太大差别，只是为了区分何时需要扩容而已 取其中最大的值作为判断本次是否需要扩容的依据，由于第一次数组是空的，所以默认要使数组扩容到10的长度。
3.4. grow方法
ensureExplicitCapacity方法 方法名翻译过来就是 扩大，就是ArrayList 的扩容方法。
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
方法中会使用Arrays类的方法：copyOf()
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
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;
}
3.5. hugeCapacity方法
hugeCapacity方法 方法名翻译过来就是 巨大的容量，就是在新数组长度超过当前数组定义的最大长度时执行的方法。
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
3.6. rangeCheckForAdd方法
rangeCheckForAdd方法 方法名翻译过来就是 添加时的容量检查，主要作用就是判断下标是否越界。
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
注意：如果下标越界则抛出IndexOutOfBoundsException异常。
3.7. rangeCheck方法
rangeCheckForAdd方法 方法名翻译过来就是 容量检查，主要作用就是判断下标是否越界。
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
注意：如果下标越界则抛出IndexOutOfBoundsException异常。
elementData方法
elementData方法 方法名翻译过来就是 元素数据，主要作用就是通过下标索引找到对应的元素值，返回指定元素。
E elementData(int index) {
return (E) elementData[index];
}
3.8. fastRemove方法
fastRemove方法 方法名翻译过来就是 快速删除，主要作用就是删除元素。
是ArrayList 的私有删除方法，跳过边界检查并且不返回删除的值。
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;
}
方法中会通过 System.arraycopy 方法将后面的元素往前移动一位
4. 操作方法
操作方法多是基于私有方法的调用。
4.1. add 操作
每次添加元素到集合中时都会先确认下集合容量大小。然后将 size 自增 1。ensureCapacityInternal 函数中判断如果 elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA 就取 DEFAULT_CAPACITY 和 minCapacity 的最大值也就是 10。这就是 EMPTY_ELEMENTDATA 与 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的区别所在。使用无参构造函数时是在第一次添加元素时初始化容量为 10 的。ensureExplicitCapacity 中对 modCount 自增 1，记录操作次数，然后如果 minCapacity 大于 elementData 的长度，则对集合进行扩容。显然第一次添加元素时 elementData 的长度为零。
// 添加单个元素,添加元素之前会先检查容量，如果容量不足则调用grow方法
public boolean add(E e) {
// 判断添加后的长度是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
// 然后在数组末尾添加当前元素，并且修改size的大小
elementData[size++] = e;
// 返回布尔值true
return true;
}
public void add(int index, E element) {
//判断下标是否越界，如果是则抛出IndexOutOfBoundsException异常
rangeCheckForAdd(index);
// 判断是否需要扩容，上面讲到过，这里不再解释
ensureCapacityInternal(size + 1); // Increments modCount!!
// 拷贝数组，将下标后面的元素全部向后移动一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 将元素插入到当前下标的位置
elementData[index] = element;
size++;
}
4.2. addAll 操作
// 添加多个元素
public boolean addAll(Collection<? extends E> c) {
return addAll(this.size, c);
}
// 添加多个元素到指定下标
public boolean addAll(int index, Collection<? extends E> c) {
// 判断下标是否越界，上面提到过
rangeCheckForAdd(index);
// 判断c的大小是否大于0
int cSize = c.size();
// 如果等于0 返回 false
if (cSize==0)
return false;
checkForComodification();
// 将元素插入到数组中
parent.addAll(parentOffset + index, c);
// 将修改次数赋值给 modCount
this.modCount = parent.modCount;
// size大小加一
this.size += cSize;
return true;
}
在进行 add 操作时先判断下标是否越界，是否需要扩容，如果需要扩容，就复制数组，然后设置对应的下标元素值。
4.3. get 操作
// 先判断下标索引
public E get(int index) {
// 调用rangeCheck判断是否超出了Object数组长度
rangeCheck(index);
// 调用 elementData 方法
return elementData(index);
}
4.4. set 操作
public E set(int index, E element) {
// 调用rangeCheck判断是否超出范围，上面讲到过，不懂的同学往上翻翻
rangeCheck(index);
// 返回指定元素，上面也讲到过
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
4.5. remove 操作
// 删除元素
public E remove(int index) {
// 调用rangeCheck方法判断是否超出范围，上面讲到过
rangeCheck(index);
modCount++;
// 位置访问操作
E oldValue = elementData(index);
// 计算移除元素后需要移动的元素个数
int numMoved = size - index - 1;
if (numMoved > 0)
// 通过 System.arraycopy 方法将后面的元素往前移动一位
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 最后一位赋值为null
elementData[--size] = null;
// 返回移除后元素的值
return oldValue;
}
// 删除对象
public boolean remove(Object o) {
// 如果对象为null
if (o == null) {
// 遍历整个list去匹配移除的值
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;
}
4.6. Iterator 操作
// ArrayList中的迭代器
public Iterator<E> iterator() {
// 主要返回一个Itr类
return new Itr();
}
Iterator 方法返回的是Itr类，以下是 Itr类源码：
private class Itr implements Iterator<E> {
int cursor; // 下一个要返回的元素的索引
int lastRet = -1; // 返回的最后一个元素的索引； -1（如果没有）
int expectedModCount = modCount;
Itr() {
}
// 判断是否还有下一个元素
public boolean hasNext() {
// 通过判断以下一个下标是否为数组大小，返回布尔值
return cursor != size;
}
@SuppressWarnings("unchecked")
// 获取下一个元素
public E next() {
// 调用checkForComodification方法检查修改的次数是否一致
checkForComodification();
// 定义下一个元素的下标
int i = cursor;
// 判断下标，如果下标大于ArrayList包含的元素个数
if (i >= size)
// 抛出 NoSuchElementException （没有这样的元素异常）异常
throw new NoSuchElementException();
// 定义elementData 为ArrayList的数组
Object[] elementData = ArrayList.this.elementData;
// 再次判断下标，如果此次判断不一致则说明数组被修改过
if (i >= elementData.length)
// 抛出 ConcurrentModificationException （并发修改）异常
throw new ConcurrentModificationException();
// 定义下一个元素的下标
cursor = i + 1;
// 将lastRet定义为下一个元素的下标（返回的最后一个元素的下标），然后返回下标对应的值
return (E) elementData[lastRet = i];
}
// 移除当前元素
public void remove() {
// 如果没有元素
if (lastRet < 0)
// 则抛出 IllegalStateException 异常
throw new IllegalStateException();
// 又来了，调用 checkForComodification，上面讲到过，用于判断修改次数是否一致
checkForComodification();
try {
// 调用ArrayList的remove方法
//如果在遍历外remove会导致Itr中的expectedModCount没有修改则抛出异常
ArrayList.this.remove(lastRet);
// 定义下一个元素的下标为当前下标
cursor = lastRet;
// 定义上个遍历下标为-1
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
final void checkForComodification() {
// 判断当前Itr修改次数和ArrayList是否一致
if (modCount != expectedModCount)
// 不一致则抛出ConcurrentModificationException（并发修改异常）异常
throw new ConcurrentModificationException();
}
5. 扩容机制
默认将扩容至原来容量的 1.5 倍。但是扩容之后也不一定适用，有可能太小，有可能太大。所以才会有下面两个 if 判断。如果1.5倍太小的话，则将我们所需的容量大小赋值给newCapacity，如果1.5倍太大或者我们需要的容量太大，那就直接拿 newCapacity = (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE 来扩容（将扩容长度设置为Interger.MAX_VALUE,也就是int的最大长度）。然后将原数组中的数据复制到大小为 newCapacity 的新数组中，并将新数组赋值给 elementData。
6. 线程是否安全
注意：ArrayList不是线程安全的。
ArrayList不是线程安全的，所以效率较高，但是只能适用于单线程，多线程可以使用 Collections.synchronizedList(List list) 函数返回一个线程安全的 ArrayList 集合，或者使用 concurrent 并发包下的CopyOnWriteArrayLis。
使用Collections.synchronizedList(List list)方法实现线程安全
List<?> list = Collections.synchronizedList(new ArrayList<>());