其实 Java 集合框架也叫做容器，主要由两大接口派生而来，一个是 collection,主要存放对象的集合。另外一个是Map, 存储着键值对（两个对象）的映射表。
下面就来说说 List接口，List存储的元素是有序、可重复的。其下有三个子接口，ArrayList、LinkedList 和 vector。
一、 ArrayList概述
ArrayList 底层数据结构是基于 Object 数组来实现的，我们看看它的底层接口源码：
1. ArrayList 实现的接口
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
其中继承的接口中的 RandomAccess、Cloneable 和 Serializable 只是标记接口，他们的接口内部没有具体的方法和参数：
public interface RandomAccess {
}
public interface Cloneable {
} //覆盖clone(),能被克隆
public interface Serializable {
} //支持序列化，能通过序列化传输
标记接口是计算机科学中的一种设计思路。编程语言本身不支持为类维护元数据。而标记接口则弥补了这个功能上的缺失——一个类实现某个没有任何方法的标记接口，实际上标记接口从某种意义上说就成为了这个类的元数据之一。运行时，通过编程语言的反射机制，我们就可以在代码里拿到这种元数据。
以Serializable接口为例。一个类实现了这个接口，说明它可以被序列化。因此，我们实际上通过Serializable这个接口，给该类标记了“可被序列化”的元数据，打上了“可被序列化”的标签。这也是标记/标签接口名字的由来。
此外AbstractList 继承AbstractCollection 抽象类，实现List接口。它实现了 List 的一些基本操作如（get,set,add,remove）,是第一实现随机访问方法的集合类，但是不支持添加和替换。
2.ArrayList 的成员属性
private static final int DEFAULT_CAPACITY = 10; //默认初始容量为10
private static final Object[] EMPTY_ELEMENTDATA = {
}; //空数组，用于空实例
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
};//用于默认大小空实例的共享空数组实例。
transient Object[] elementData; //保存ArrayList数据的数组，transient修饰表示数组默认不会被序列化
private int size; //ArrayList中数组的个数
二、ArrayList 中的方法
Java ArrayList 中常用的方法：
| 方法 | 描述 |
|---|---|
| add() | 将元素插入到指定位置的 arraylist 中 |
| addAll() | 添加集合中的所有元素到 arraylist 中 |
| clear() | 删除 arraylist 中的所有元素 |
| clone() | 复制一份 arraylist |
| contains() | 判断元素是否在 arraylist |
| get() | 通过索引值获取 arraylist 中的元素 |
| indexOf() | 返回 arraylist 中元素的索引值 |
| removeAll() | 删除存在于指定集合中的 arraylist 里的所有元素 |
| remove() | 删除 arraylist 里的单个元素 |
| size() | 返回 arraylist 里元素数量 |
| isEmpty() | 判断 arraylist 是否为空 |
| subList() | 截取部分 arraylist 的元素 |
| set() | 替换 arraylist 中指定索引的元素 |
| sort() | 对 arraylist 元素进行排序 |
| toArray() | 将 arraylist 转换为数组 |
| toString() | 将 arraylist 转换为字符串 |
| ensureCapacity() | 设置指定容量大小的 arraylist |
| lastIndexOf() | 返回指定元素在 arraylist 中最后一次出现的位置 |
| retainAll() | 保留 arraylist 中在指定集合中也存在的那些元素 |
| containsAll() | 查看 arraylist 是否包含指定集合中的所有元素 |
| trimToSize() | 将 arraylist 中的容量调整为数组中的元素个数 |
| removeRange() | 删除 arraylist 中指定索引之间存在的元素 |
| replaceAll() | 将给定的操作内容替换掉数组中每一个元素 |
| removeIf() | 删除所有满足特定条件的 arraylist 元素 |
| forEach() | 遍历 arraylist 中每一个元素并执行特定操作 |
具体的方法细节可以看这里
三、ArrayList 中的扩容机制
在初始化时，ArrayList 有三种方式来进行初始化，以无参构造方法创建 ArrayList 时，实际上赋值的是一个空数组。当真正对数组进行添加元素时，才真正的给 ArrayList 分配容量，即数组容量扩为10。
/**
*默认构造函数，使用初始容量10构造一个空列表(无参数构造)
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 带初始容量参数的构造函数。（用户自己指定容量）
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//初始容量大于0
//创建initialCapacity大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//初始容量等于0
//创建空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
//初始容量小于0，抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
*构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
*如果指定的集合为null，throws 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;
}
}
/**
* 将指定的元素追加到此数组的末尾。
*/
public boolean add(E e) {
//在增加元素前，先调用ensureCapacityInternal方法
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//比较当前元素个数和默认元素个数，如果小于10，则将最小容量设为默认值10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//继续调用 ensureExplicitCapacity()方法
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
//如果大于当前数组默认长度，则进行扩容，调用grow()方法
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* 要分配的最大数组大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//在以前的容量基础上增加旧容量的1/2
int newCapacity = oldCapacity + (oldCapacity >> 1);
//检查比较新容量与最小容量的大小，取大值
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//更新完新容量后，比较是否大于最大数组大小 Integer.MAX_VALUE - 8
if (newCapacity - MAX_ARRAY_SIZE > 0)
//若大于最大数组大小，则调用hugeCapacity()方法
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();
//对minCapacity和MAX_ARRAY_SIZE进行比较
//若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
//若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
四、ArrayList 相关面试题
1. System.arraycopy() 和 Arrays.copyOf() 的区别
联系：
看两者源代码可以发现 copyOf()内部实际调用了 System.arraycopy() 方法
区别：
arraycopy() 需要目标数组，将原数组拷贝到你自己定义的数组里或者原数组，而且可以选择拷贝的起点和长度以及放入新数组中的位置 copyOf() 是系统自动在内部新建一个数组，并返回该数组。
2. ArrayList 和 LinkedList 的区别
- 是否保证线程安全：
ArrayList和LinkedList都是不同步的，也就是不保证线程安全； - 底层数据结构：
Arraylist底层使用的是Object数组；LinkedList底层使用的是 双向链表 数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！） - 插入和删除是否受元素位置的影响： ①
ArrayList采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。 比如：执行add(E e)方法的时候，ArrayList会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ②LinkedList采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置i插入和删除元素的话（(add(int index, E element)） 时间复杂度近似为o(n))因为需要先移动到指定位置再插入。 - 是否支持快速随机访问：
LinkedList不支持高效的随机元素访问，而ArrayList支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。 - 内存空间占用：
ArrayList的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。
3. ArrayList 和 Vector 的区别
ArrayList是List的主要实现类，底层使用Object[ ]存储，适用于频繁的查找工作，线程不安全 ；Vector是List的古老实现类，底层使用Object[ ]存储，线程安全的。如下代码带有synchronized同步锁，能够保证线程安全。
public synchronized void ensureCapacity(int minCapacity) {
if (minCapacity > 0) {
modCount++;
ensureCapacityHelper(minCapacity);
}
}
4. ArrayList 和 CopyOnWriteArrayList 的区别
CopyOnWriteArrayList 和 Vector 一样也是线程安全的 List 。它在 java.util.concurrent 的包下。它的线程安全主要是通过读写分离来实现的。写操作在一个复制的数组上实现（加锁），读操作还是在原数组中进行。
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
final void setArray(Object[] a) {
array = a;
}
特点：适合读多写少的应用场景
缺点：
- 内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
- 数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中；
五、参考资料
