Vector 底层是用数组实现的，相关的方法都加了同步检查，因此“线程安全,效率低”。比如，indexOf 方法就增加了 synchronized 同步标记。

Vector 的使用

Vector 的使用与 ArrayList 是相同的，因为他们都实现了 List 接口，对 List 接口中的抽象方法做了具体实现。

public class VectorTest {
    public static void main(String[] args) {
        //实例化 Vector
        List < String > v = new Vector < > ();
        v.add("a");
        v.add("b");
        v.add("a");
        for (int i = 0; i < v.size(); i++) {
            System.out.println(v.get(i));
        }
        System.out.println("----------------------");
        for (String str: v) {
            System.out.println(str);
        }
    }
}

Vector 和 ArrayList 的区别

Vector线程安全，效率低；ArrayList线程不安全，效率高

Vector 初始化对象数组长度为10，ArrayList初始化对象数组长度为0

/**
 * 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;
public Vector() {
    this(10);
}
/**
 * Constructs an empty vector with the specified initial capacity and
 * capacity increment.
 *
 * @param initialCapacity the initial capacity of the vector
 * @param capacityIncrement the amount by which the capacity is
 * increased when the vector overflows
 * @throws IllegalArgumentException if the specified initial capacity
 * is negative
 */
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: " +
            initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

Vector 扩容为2倍，ArrayList扩容为1.5倍

/**
 * This implements the unsynchronized semantics of ensureCapacity.
 * Synchronized methods in this class can internally call this
 * method for ensuring capacity without incurring the cost of an
 * extra synchronization.
 *
 * @see #ensureCapacity(int)
 */
private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    //判断是否需要扩容，数组中的元素个数-数组长度，如果大于 0 表明需要扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //扩容 2 倍
    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);
}