另外需要提醒注意的是，不像ArrayList，如果是用Vector的默认构造函数创建实例，那么第一次添加元素就需要扩容，但不会扩容到默认容量10，只会根据用户指定或两倍的大小扩容。所以使用Vector时指不指定扩容大小都很尴尬：

• 如果容量大小和扩容大小都不指定，开始可能会频繁地进行扩容
• 如果指定了容量大小不指定扩容大小，以2倍的大小扩容会浪费很多资源
• 如果指定了扩容大小，扩容大小就固定了，不管数组多大，都按这大小来扩容，那么这个扩容大小的取值总有不理想的时候

从Vector我们也可以反观ArrayList设计巧妙的地方，这也许是Vector存在的唯一价值了哈哈。

3：Stack继承于Vector，在其基础上扩展了栈的方法
Stack我们也不使用了，它只是添加多几个栈常用的方法（这个LinkedList也有，后面讨论），简单来看下它们的实现吧：

// 进栈

public E push(E item) {

    addElement(item);

    return item;

}

// 出栈

public synchronized E pop() {

    E       obj;

    int     len = size();

    obj = peek();

    removeElementAt(len - 1);

    return obj;

}

public synchronized E peek() {

    int     len = size();

    if (len == 0)

        throw new EmptyStackException();

    return elementAt(len - 1);

}

// 链尾追加

void linkLast(E e) {

    final Node<E> l = last;

    final Node<E> newNode = new Node<>(l, e, null);

    last = newNode;

    if (l == null)

        first = newNode;

    else

        l.next = newNode;

    size++;

    modCount++;

}

// 指定节点前插入

void linkBefore(E e, Node<E> succ) {

    // assert succ != null;

    // 插入节点，succ为Index的节点，可以看到，是插入到index节点的前一个节点

    final Node<E> pred = succ.prev;

    final Node<E> newNode = new Node<>(pred, e, succ);

    succ.prev = newNode;

    if (pred == null)

        first = newNode;

    else

        pred.next = newNode;

    size++;

    modCount++;

}

public void add(int index, E element) {

    checkPositionIndex(index);

    if (index == size)

        linkLast(element);

    else

        linkBefore(element, node(index));

}

E unlink(Node<E> x) {

    // assert x != null;

    final E element = x.item;

    final Node<E> next = x.next;

    final Node<E> prev = x.prev;

    if (prev == null) {

        // 链头

        first = next;

    } else {

        prev.next = next;

        x.prev = null;

    }

    if (next == null) {

        // 链尾

        last = prev;

    } else {

        next.prev = prev;

        x.next = null;

    }

    x.item = null;

    size--;

    modCount++;

    return element;

}

public E remove(int index) {

    checkElementIndex(index);

    return unlink(node(index));

}

Node<E> node(int index) {

    // 使用了二分法

    if (index < (size >> 1)) { // 如果索引小于二分之一，从first开始遍历

        Node<E> x = first;

        for (int i = 0; i < index; i++)

            x = x.next;

        return x;

    } else { // 如果索引大于二分之一，从last开始遍历

        Node<E> x = last;

        for (int i = size - 1; i > index; i--)

            x = x.prev;

        return x;

    }

}

public E get(int index) {

    checkElementIndex(index);

    return node(index).item;

}

所以，LinkedList和ArrayList刚好是互补的，所以具体场景，应考虑哪种操作最频繁，从而选择不同的List来使用。

2：LinkedList可以当作队列和栈来使用
不知大家有没注意到在图2.2中，LinkedList非常“特立独行地”继承了Deque接口，而Deque又继承于Queue接口，这队列和栈的方法定义就是在这些接口中定义的，而LinkedList实现其方法，使自身具备了队列的栈的功能。
当作队列（先进先出）使用：

// 进队

public boolean offerFirst(E e) {

    addFirst(e);

    return true;

}

// 出队

public E pollLast() {

    final Node<E> l = last;

    return (l == null) ? null : unlinkLast(l);

}

// 进栈

public void push(E e) {

    addFirst(e);

}

// 出栈，如果为空列表，会抛出异常

public E pop() {

    return removeFirst();

}

static class SynchronizedCollection<E> implements Collection<E>, Serializable {

    private static final long serialVersionUID = 3053995032091335093L;

    final Collection<E> c; // 装饰的集合

    final Object mutex; // 锁

    SynchronizedCollection(Collection<E> c) {

        this.c = Objects.requireNonNull(c);

        mutex = this;

    }

    SynchronizedCollection(Collection<E> c, Object mutex) {

        this.c = Objects.requireNonNull(c);

        this.mutex = Objects.requireNonNull(mutex);

    }

}

可以看到，可以指定一个对象作为锁，如果不指定，默认就锁了集合了。
再来看下我们关注的SynchronizedList：

static class SynchronizedList<E>

    extends SynchronizedCollection<E>

    implements List<E> {

    final List<E> list;

    SynchronizedList(List<E> list) {

        super(list);

        this.list = list;

    }

    SynchronizedList(List<E> list, Object mutex) {

        super(list, mutex);

        this.list = list;

    }

    ...

    public E get(int index) {

        synchronized (mutex) {return list.get(index);}

    }

    public E set(int index, E element) {

        synchronized (mutex) {return list.set(index, element);}

    }

    public void add(int index, E element) {

        synchronized (mutex) {list.add(index, element);}

    }

    public E remove(int index) {

        synchronized (mutex) {return list.remove(index);}

    }

    ...

}