JDK源码阅读Vector

Vector的直接子类是Stake
Vector和ArrayList类似，都是可变数组，不同的是Vector在涉及到增加、删除、修改时加了关键字synchronized
Vector类的声明和集成关系以及属性

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    /**
     * The array buffer into which the components of the vector are
     * stored. The capacity of the vector is the length of this array buffer,
     * and is at least large enough to contain all the vector's elements.
     *
     * <p>Any array elements following the last element in the Vector are null.
     *
     * @serial
     */
    protected Object[] elementData;

    /**
     * The number of valid components in this {@code Vector} object.
     * Components {@code elementData[0]} through
     * {@code elementData[elementCount-1]} are the actual items.
     *
     * @serial
     */
    protected int elementCount;

    /**
     * The amount by which the capacity of the vector is automatically
     * incremented when its size becomes greater than its capacity.  If
     * the capacity increment is less than or equal to zero, the capacity
     * of the vector is doubled each time it needs to grow.
     *
     * @serial
     */
    protected int capacityIncrement;

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -2767605614048989439L;
     public Vector(int initialCapacity, int capacityIncrement) {//指定初始化数组的大小和扩展时的增量
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    /**
     * Constructs an empty vector with the specified initial capacity and
     * with its capacity increment equal to zero.
     *
     * @param   initialCapacity   the initial capacity of the vector
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public Vector(int initialCapacity) {//也可以自己指定初始化数组容量
        this(initialCapacity, 0);
    }

    /**
     * Constructs an empty vector so that its internal data array
     * has size {@code 10} and its standard capacity increment is
     * zero.
     */
    public Vector() {//无参构造器默认数组大小是10
        this(10);
    }

Vector对数组的扩展方式与ArrayList不同，要么按给定的增量增加，要么增加一倍

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
  private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

注意：
Java的Vector类被认为是过时的或者废弃的原文地址
问题

为什么java Vector类被认为是一个遗留的，过时的或废弃的类？在并发操作时，使用它是无效的吗？

如果我不想手动对对象实现同步，只想用一个线程安全的集合而无需创建底层数组的全新副本（如CopyOnWriteArrayList一样）。这种情况下，我使用Vector合理吗?

然后就是关于栈的问题，它是Vector的一个子类，我应该用什么代替它？

回答
Vector中对每一个独立操作都实现了同步，这通常不是我们想要的做法。对单一操作实现同步通常不是线程安全的（举个例子，比如你想遍历一个Vector实例。你仍然需要申明一个锁来防止其他线程在同一时刻修改这个Vector实例。如果不添加锁的话

通常会在遍历实例的这个线程中导致一个ConcurrentModificationException）同时这个操作也是十分慢的(在创建了一个锁就已经足够的前提下，为什么还需要重复的创建锁)

当然，即使你不需要同步，Vector也是有锁的资源开销的。

总的来说，在大多数情况下，这种同步方法是存在很大缺陷的。正如Mr Brain Henk指出，你可以通过调用Collections.synchronizedList来装饰一个集合 -事实上 Vector 将“可变数组”的集合实现与“同步每一个方法”结合起来的做法是另一个糟糕的设计；

各个装饰方法能够更明确的指示其关注的功能实现。

对于Stack这个类-我更乐于使用Deque/ArrayDeque来实现