1、简介
ArrayList是java集合框架常用的集合类之一，底层是基于数组来实现容量大小动态变化的。
2、类图（JDK 1.8）
下图是ArrayList实现的接口和继承的类关系图：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
1、实现了四个接口
1.1. java.util.List 接口，提供数组的添加、删除、修改、迭代遍历等操作。
1.2. java.util.RandomAccess 接口，表示 ArrayList 支持快速的随机访问。（RandomAccess 是 List 实现所使用的标记接口，用来表明其支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。）
1.3. java.io.Serializable 接口，表示 ArrayList 支持序列化的功能。
1.4. java.lang.Cloneable 接口，表示 ArrayList 支持克隆。
2、继承了AbstractList抽象类
2.1AbstractList抽象类就是List分支的顶层超类。此类提供了List接口的骨干实现，以最大限度地减少实现由“随机访问”数据存储（例如数组、链表）支持的此接口所需的工作量
三、常用方法
添加元素 add()
/**
* Appends the specified element to the end of this list.
* 添加单个元素方法
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
//判断如果容量不够，进行扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//设置到数组末尾，然后在size+1
elementData[size++] = e;
return true;
}
//保证数组大小是否足够，不足则1.5倍扩容
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//计算数组，最小需要的长度
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//new ArrayList()初始化的时候 elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA
//在添加的时候在初始化长度为10的数组
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
//判断数组容量是否足够，不足进行扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);//数组扩容
}
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
* 数组扩容，增加容量以确保它至少可以容纳最小容量参数指定的元素数
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//新数组长度是旧数组的1.5倍
if (newCapacity - minCapacity < 0)//判断新数组需要的长度，是否比需要数组需要的最小容量小
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//判断新数组长度是否大于MAX_ARRAY_SIZE【2147483647-8】
newCapacity = hugeCapacity(minCapacity);//判断 最小容量大于MAX_ARRAY_SIZE返回Integer.MAX_VALUE 否则返回 MAX_ARRAY_SIZE
elementData = Arrays.copyOf(elementData, newCapacity);//复制当前数组到一个新数组（长度为newCapacity），并返回
}
//判断 最小容量大于MAX_ARRAY_SIZE返回Integer.MAX_VALUE 否则返回 MAX_ARRAY_SIZE
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
流程图：
get方法 get()
根据下标获取元素
public E get(int index) {
rangeCheck(index);//判断当前下标是否数组越界，越界抛出IndexOutOfBoundsException异常
//根据数组下标获取元素
return elementData(index);
}
//判断当前下标是否数组越界，越界抛出IndexOutOfBoundsException异常
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//根据数组下标获取元素
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
删除元素 remove()
1、public E remove(int index)
删除列表中指定位置的元素。将任何后续元素向左移动
//根据下标删除数组元素，下标右边元素向左移
public E remove(int index) {
rangeCheck(index);//判断当前下标是否数组越界，越界抛出IndexOutOfBoundsException异常
modCount++;//数组修改+1
E oldValue = elementData(index);//根据下标获取数组元素
int numMoved = size - index - 1;//元素向左移动的长度
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);//当前下标-后续元素向左移动
//先size-1设置null删除元素，方便gc回收
elementData[--size] = null; // clear to let GC do its work
return oldValue;//返回旧的值
}
2、public boolean remove(Object o)
删除数组的第一个匹配元素，
//删除数组的第一个匹配的元素
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);//根据下标删除元素，逻辑同remove(int index)方法
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);//根据下标删除元素，逻辑同remove(int index)方法
return true;
}
}
return false;
}
获取元素下标 indexOf()
//取得当前元素下标，查找不到返回-1 代码逻辑跟 remove(Object 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;
}
时间复杂度
add(E e)方法 添加元素到末尾
时间复杂度为O(1)。
add(int index, E element)方法 添加元素到指定位置
时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n) 。
最好时间复杂度发生在末尾添加的情况。
get(int index)方法 获取指定索引位置的元素
数组在内存中是连续的地址空间，可以直接通过下标去数组查找元素，时间复杂度为O(1)。
remove(int index)方法 删除指定索引位置的元素
最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n) 。
remove(Object o)方法 删除指定元素值的元素
由于要先找到元素 O(n)，然后在通过下标删除元素 O(n)， 时间复杂度为O(n)。
小结
1、存储一组不唯一（可以有多个元素引用相同的对象），有序的对象，按照插入顺序的保证有序，元素可以重复，支持null元素
2、按照1.5倍的容量去扩容
2.1、非线程安全。解释一下什么是线程安全：
2.2、当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。
----《并发编程实战》
多线程并发访问时，得不到正确的结果。
