源码浅析 ArrayList、Vector、LinkedList 的区别

从类的定义浅析

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.Serializablepublic 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() 方法将其转换成线程安全的容器后再使用（这是对装潢模式的应用，将已有对象传入另一个类的构造器中创建新的对象来增强实现）。