概念
ArrayList就是一个底层是数组形式组成的有序集合，允许重复数据，允许数据为null,但是非线程安全，让我们看看源码
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
我们看到ArrayList实现了RondomAccess接口，这也就意味着该类支持快速随机访问
以下是ArrayList的主要成员变量
private static final int DEFAULT_CAPACITY = 10;//默认初始容量为10
private static final Object[] EMPTY_ELEMENTDATA = {};//定义一个空数组实例
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private transient Object[] elementData;//存放数据的数组
private int size;//数组的大小
注意一下，elementData是由transient修饰的，ArrayList继承了Serializable,实现了序列化，elementData是一个缓存数组,它通常会预留一些容量，在很多时候，这个数组都有很多空的数据，所以如果存进内存，会占用多余的内存空间，故使用transient反序列化。
创建
当我们new一个ArrayList时，有三种构造方式：
1.无参构造器，默认创建一个空的数组
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
当添加了第一条数据后，elementData初始容量为10；
2.指定集合的大小
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
如图，指定初始容量时，elementData的大小为指定值，当我们知道集合所需容量大小时，可以在创建集合时直接指定它的大小
3.构造一个包含指定集合的Arraylist
public ArrayList(Collection c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
添加
先让我们看一段代码
ArrayList list = new ArrayList<>();
list.add("hello");
list.add("world");
让我们看一下源码，看看底层是怎么做的
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 索引增加
elementData[size++] = e;
return true;
}
ensureCapacityInternal()是扩容方法，先不管，实际添加数据就是直接在elementData数组的后面添加了数据。
那么看看扩容的操作
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
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);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
首先判断当前数组是否为空，若当前数组不为空，且当前数组的长度小于插入数据之后的长度，则调用grow()方法进行扩容，我们从int newCapacity = oldCapacity + (oldCapacity >> 1)可以看出，扩容之后的容量为之前的1.5倍，然后进行Arrays.copy()操作将之前的数组中的数据复制到新数组。
删除
我们一般常用到的删除方式分别是指定下标删除，和指定内容删除，让我们看看源代码是怎么做的
/*
* 通过制定下标删除
*/
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; // clear to let GC do its work
return oldValue;
}
/*
* 通过指定对象删除
*/
public boolean remove(Object o) {
if (o == 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++;
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
}
这两种删除的方式都差不多，都是要把指定元素后面位置的所有元素，利用System.arraycopy方法整体向前移动一个位置，最后一个位置的元素指定为null，这样让gc可以去回收它
插入
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
插入元素的时候，也是要利用System.arraycopy()整体往后移，将元素放在指定位置，数组的大小增1
总结
ArrayList底层是用数组实现的，具有动态扩容特性。初始容量为10，扩容增量为原容量的1.5
ArrayList具有随机访问特性，查找速度快
ArrayList插入和删除操作效率比较低，因为涉及到元素复制，当需要复制的元素过多时，比较耗费性能。
因此，ArrayList比较适合顺序添加、随机访问的场景。
小插曲：System.arraycopy()和Arrays.copyOf()的方法的区别？
以下是它们的源码：
/*
* System.arraycopy
*/
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
/*
* Arrays.copyOf
*/
public static short[] copyOf(short[] original, int newLength) {
short[] copy = new short[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
arraycopy()是native方法，所以看不到arraycopy()的具体实现，哭(ꀕڡꀕ)
我们看到Arrays.copy()的最后还是调用了System.arraycopy(),Arrays.copy()限制了复制的范围只能是整个数组