# Vector 与 Stack

1.  隶属于 List 族系，Vector 在数组基础上实现了按需增减容量的特性，内部通过维持一个数组实现

2.  迭代器 和 Enumeration 均为 fail-fast

3.  Vector 是线程安全的（使用 synchronized 修饰符），如果不需要线程安全应该选用 ArrayList

4.  Vector 的构造函数中能够指定初始容量和增长步长，

不指定步长时默认步长为 0（容量 X2 增长），不指定容量默认为 10

public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}

public Vector(int initialCapacity) {
this(initialCapacity, 0);
}

public Vector() {
this(10);
}

当然，扩容时，如果 + 设定步长 或者 容量翻倍 都没有达到容量要求，会直接使用目标容量

最大容量不超过整数范围

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);
}

private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}

5.  把数组元素置为 null，使 gc 对其回收

public synchronized void removeElementAt(int index) {
modCount++;
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
else if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}
int j = elementCount - index - 1;
if (j > 0) {
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--;
elementData[elementCount] = null; /* to let gc do its work */
}

public synchronized void removeAllElements() {
modCount++;
// Let gc do its work
for (int i = 0; i < elementCount; i++)
elementData[i] = null;

elementCount = 0;
}

6.   sort 方法能够传入一个 Comparator，内部调用的是 Arrays.sort()

public synchronized void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, elementCount, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}

7.   Stack 在 Vector 基础上，控制了操作的位置（只能在一端进行），后进先出

提供了 push/pop/peek/empty 栈操作的典型方法

如果需要更复杂的功能，可以使用 Deque

Deque<Integer> stack = new ArrayDeque<Integer>();

Stack 线程安全的