ArrayList简介
ArrayList 是 Java 集合框架中比较常用的数据结构了。ArrayList是可以动态增长和缩减的索引序列，内部封装了一个动态再分配的Object[]数组
这里我们可以看到ArrayList继承抽象类AbstractList，实现了 List 接口，同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。
主要成员变量
// 底层存储元素的数组
transient Object[] elementData;
// ArrayList的实际大小
private int size;
复制代码
注意：size 才是 elementData数组中实际的元素个数，而 elementData.length 为数组的容量，表示最多可以容纳多少个元素。
// ArrayList的默认初始化容量
private static final int DEFAULT_CAPACITY = 10;
复制代码
ArrayList的默认初始容量大小为 10。
// 记录对List操作的次数
protected transient int modCount = 0;
复制代码
这个变量是定义在 AbstractList 中的，主要使用是在 Iterator，目的是防止在List在迭代的过程中被修改。
// 空的Object类型数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 空的Object类型数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
复制代码
两个空的数组有什么区别呢？简单来讲就是第一次添加元素（使用add方法）时知道elementData是从空的构造函数还是有参构造函数被初始化的。以便确认下一步的扩容机制。
构造函数
ArrayList类共有三种构造函数：
无参构造函数带有参数为初始容量initialCapacity的构造函数带有参数为Collection集合的构造函数
1、无参构造函数
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
复制代码
注意：虽然在源码的注释中说该构造函数构造一个容量大小为 10 的空的ArrayList，但实际上构造函数只是给 elementData 赋值了一个空的数组（DEFAULTCAPACITY_EMPTY_ELEMENTDATA），在第一次向ArrayList添加元素时容量才扩大至10的。
2、带有参数为初始容量initialCapacity的构造函数
public ArrayList(int initialCapacity) {
// 如果initalCapacity大于0，直接创建一个长度Object数组赋值为elementData；
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
}
// 如果initalCapcity等于0，直接将空数组EMPETY_ELEMENTDATA复制给elementData
else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
}
// 如果initalCapcity小于于0，则抛出异常IllegalArgumentException
else {
throw new IllegalArgumentException(“Illegal Capacity: “+
initialCapacity);
}
}
复制代码
当 initialCapacity 为0时则是把 EMPTY_ELEMENTDATA 赋值给 elementData。 当 initialCapacity 大于零时初始化一个大小为 initialCapacity 的 object 数组并赋值给 elementData。
3、带有参数为Collection集合的构造函数
public ArrayList(Collection<? extends E> c) {
// 将 Collection 转化为数组并赋值给elementData
elementData = c.toArray();
// 把elementData中元素的个数赋值给size并判断其是否为0
if ((size = elementData.length) != 0) {
// 如果 size 不为零，则判断 elementData 的 class 类型是否为 Object[]，不是的话则做一次转换。
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
// 如果 size 为零，则把 EMPTY_ELEMENTDATA 赋值给 elementData，相当于new ArrayList(0)。
else {
this.elementData = EMPTY_ELEMENTDATA;
}
}
复制代码
该构造方法主要就是将Collection集合的实现类转换为ArrayList。
主要操作方法
add方法（添加单个元素）
public boolean add(E e) {
// 先确认ArrayList集合容量大小
ensureCapacityInternal(size + 1);
// 先给elementData中size位置赋值为e，然后size自增
elementData[size++] = e;
return true;
}
复制代码
private void ensureCapacityInternal(int minCapacity) {
// 如果elementData为默认的空数组，则给minCapacity赋值为初始的默认容量
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
// modCount自增，并确定容量大于数组的长度
ensureExplicitCapacity(minCapacity);
}
复制代码
private void ensureExplicitCapacity(int minCapacity) {
// modCount自增，修改次数加1
modCount++;
// 如果minCapacity超过了数组长度，则进行扩容
if (minCapacity – elementData.length > 0)
grow(minCapacity);
}
复制代码
上述三个函数的调用关系很简单，也很清楚。
在add方法中，每次添加元素到ArrayList中时都会先确认下集合容量大小，然后将size位置的元素赋值为e，size再进行自增。在ensureCapacityInternal方法中先对elementData进行判断 ，如果elementData为 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 就取 DEFAULT_CAPACITY 和 minCapacity 的最大值也就是10。这就是 EMPTY_ELEMENTDATA 与 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的区别所在。同时也验证了上面的说法：使用无参构造函数时是在第一次添加元素时初始化容量为10 。ensureExplicitCapacity 方法中首先对modCount 自增1，记录操作次数，然后如果 minCapacity 大于 elementData 的长度，则对集合进行扩容。显然当第一次添加元素时 elementData 的长度为零。那我们来看看 grow 函数。
private void grow(int minCapacity) {
// ArrayList的旧容量为数组长度
int oldCapacity = elementData.length;
// 将新容量赋值为原容量的1.5倍（左移一位相当于除以二）
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果此时新容量还是小于添加元素后的容量，则将新容量直接赋值为添加元素后的容量
if (newCapacity – minCapacity < 0)
newCapacity = minCapacity;
// 如果此时新容量大于数组的最大大小，则返回上限最大的容量
if (newCapacity – MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 把旧的数组elementData拷贝到新的elementData，并将容量设置为newCapacity
elementData = Arrays.copyOf(elementData, newCapacity);
}
复制代码
默认将list的容量扩容至原来容量的 1.5 倍。但是扩容之后也不一定适用，有可能太小，有可能太大。所以才会有下面两个 if 判断。如果1.5倍太小的话，则将增加元素的容量大小赋值给newCapacity，如果1.5倍太大或者我们需要的容量太大，则调用hugeCapacity函数，给newCapacity赋一个合适的值。最后将原数组中的数据复制到大小为 newCapacity 的新数组中，并将新数组赋值给 elementData。
private static int hugeCapacity(int minCapacity) {
// 如果minCapacity小于0，就抛出异常
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
// 如果此时增加元素后得minCapacity大于数组的最大长度就返回整数最大值，否则返回数组最大值
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
复制代码
add方法（批量添加，在指定位置添加）
public void add(int index, E element) {
// 检查index是否越界
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
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
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
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)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
复制代码
这三个方法基本思路与上述add方法基本思路是一致，博主这里就不再赘述了。
remove方法
public E remove(int index) {
// 检查index是否越界，如果越界则抛出异常
rangeCheck(index);
// modCount自增，修改次数加一
modCount++;
// 获取elementData在index位置的值
E oldValue = elementData(index);
// 获取后移的位置长度
int numMoved = size – index – 1;
// 如果大于零，则调用System.arraycopy方法完成数组移动
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
// size自减，并将elementData索引值为size的元素引用赋值为空，让GC对他进行回收
elementData[–size] = null;
// 返回index位置的值
return oldValue;
}
复制代码
当我们调用 remove(int index) 时，首先会检查 index 是否合法，然后再判断要删除的元素是否位于数组的最后一个位置。如果 index 不是最后一个，就再次调用 System.arraycopy() 方法拷贝数组。说白了就是将从 index + 1 开始向后所有的元素都向前挪一个位置。然后将数组的最后一个位置空，size – 1。如果 index 是最后一个元素那么就直接将数组的最后一个位置空，size – 1即可。
public boolean remove(Object o) {
// 如果o为空，则查找数组中为空的索引，并调用fastRemove方法进行删除，并返回true
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
}
// 如果o不为空，则查找数组中与该元素相等的索引，并调用fastRemove方法进行删除，并返回true
else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
// 如果list中不存在则返回false
return false;
}
复制代码
下面我们在看fastRemove方法，fastRemove方法相较于remove（int index）方法少了一步对index的判断，因为remove（Object o）就是在数组中进行查询一定是合法的，所以在fastRemove中没必要对index进行判断。
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
}
复制代码
get方法
public E get(int index) {
// 检查index是否合法，是否越界
rangeCheck(index);
// 利用数组的特点，直接访问数组中该索引位置上的元素
return elementData(index);
}
复制代码
总结
ArrayList可以存放null。ArrayList本质上就是一个elementData数组。ArrayList区别于数组的地方在于能够自动扩展大小，其中关键的方法就是gorw()方法。ArrayList中removeAll(collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是全是删除集合中的元素。ArrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果ArrayList实现了RandomAccess，所以在遍历它的时候推荐使用for循环。原文作者：前程有光
原文链接：
https://juejin.cn/post/6911944296451506190
文章来源：掘金
侵权请联系删除
