从类的定义浅析
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
首先从继承父类来看：
ArrayList & Vector 都继承了AbstractList 抽象类（提供了
List 接口的默认实现，支持随机访问）；
LinkedList 继承了 AbstractSequentialList（提供了
List 接口的简化实现，简化在只支持按次序访问）；
其次从实现接口来看：
①、三者都实现了 List 接口（定义了列表必须实现的方法）、Cloneable 接口（可以调用Object.clone方法返回该对象的浅拷贝）、java.io.Serializable 接口（支持序列化和反序列化）；
②、ArrayList & Vector 两者都实现了 RandomAccess 接口（提供了快速随机访问存储的元素的功能），而 LinkedList 实现了 Deque 接口（支持双向队列）
从类的属性浅析
ArrayList.java
private static final int DEFAULT_CAPACITY = 10; // 默认容量
transient Object[] elementData; // 装元素的容器，不可序列化
private int size; // ArrayList 的大小
Vector.java
protected Object[] elementData; // 装元素的容器
protected int elementCount; // Vector 的大小
protected int capacityIncrement; // 每次 Vector 容量增加时的增量值
LinkedList.java
transient int size = 0; // LinkedList 的大小
transient Node<E> first; // 头指针
transient Node<E> last; // 尾指针
// 结点的定义
private static class Node<E> {
E item; // 结点值
Node<E> next; // 下一个结点
Node<E> prev; // 前一个结点
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
由上源码可知：
①、ArrayList & Vector 两者底层的数据结构是数组结构，所以改查很快，增删较慢（又因为 Vector 是线程同步的，所以增删改查都比 ArrayList 慢）。而 LinkedList 的底层的数据结构是链表结构，所以改查较慢，增删较快。
②、ArrayList & Vector 底层都维护了一个 Object[] 对象数组用于存储对象，默认数组的长度是 10。但是 ArrayList 的对象数组，通过 transient 修饰，不可序列化。
③、Vector 维护了一个 capacityIncrement 字段，可以通过构造器去设置每次扩容的大小，而 ArrayList 没有。
从类的扩容方法浅析
ArrayList.java
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 扩容
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 数组扩容：增大 0.5 倍
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);
}
Vector.java
public synchronized boolean add(E e) {
modCount++;
// 扩容方法
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 数组扩容：增大 1 倍（capacityIncrement 表示每次 Vector 容量增加时的增量值）
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
由上源码可知：
ArrayList 扩容时，容量自动增长为原来的容量的 1.5 倍，而 Vector 的容量自动增长为原来的容量的 2 倍。
从遍历的方法浅析
三者都支持三种遍历方式：for-each()（几乎与迭代器一样）、迭代器方式、下标递增或递减循环。
ArrayList，下标递增或递减循环方式是速度最快的，但是 for-each() 实现更加简单，且速度没慢太多，推荐使用。
LinkedList，for-each() 方式是速度最快的。
总结
①、
ArrayList & Vector 支持随机访问；
LinkedList 只支持按次序访问；
②、
三者都定义了列表必须实现的方法、可以调用Object.clone方法返回该对象的浅拷贝、支持序列化和反序列化；
③、
ArrayList & Vector 提供了随机访问功能；
LinkedList 支持双向队列；
④、
ArrayList & Vector 是数组结构，所以改查很快，增删较慢（又因为 Vector 是线程同步的，所以增删改查都比 ArrayList 慢）。
LinkedList 是链表结构，所以改查较慢，增删较快。
⑤、
ArrayList & Vector 底层都维护了一个 Object[] 对象数组用于存储对象，默认数组的长度是 10。
但是 ArrayList 的对象数组，通过 transient 修饰，不可序列化。
⑥、
Vector 维护了一个 capacityIncrement 字段，可以通过构造器去设置每次扩容的大小，而 ArrayList 没有。
⑦、
ArrayList 扩容时，容量自动增长为原来的容量的 1.5 倍；
Vector 扩容时，容量自动增长为原来的容量的 2 倍。
⑧、
无论哪种，都推荐使用 for-each() 遍历的方式。
注意：Vector 属于遗留容器，已经不推荐使用。
Q：但 ArrayList 和 LinkedListed 都是非线程安全的，所以如果遇到多个线程操作同一个容器的场景，该怎么处理？
A：可以通过工具类 Collections 中的 synchronizedList() 方法将其转换成线程安全的容器后再使用（这是对装潢模式的应用，将已有对象传入另一个类的构造器中创建新的对象来增强实现）。
