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 线程安全的