Vector是線程安全的ArrayList,自JDK1.0開始就有了,而ArrayList是在JDK1.2才開始有的.Vector的也是基于動態(tài)數(shù)組的,實現(xiàn)邏輯與ArrayList幾乎一模一樣,主要區(qū)別在與增刪改查方法上增加了synchronized關(guān)鍵字,用來保障多線程安全.Stack是Vector的唯一子類,用來實現(xiàn)棧操作push/pop,它本質(zhì)上也是基于數(shù)組實現(xiàn)的。

下面是Vector的結(jié)構(gòu)圖:

vector.jpg

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
    protected Object[] elementData;
    protected int elementCount;
    protected int capacityIncrement;
    private static final long serialVersionUID = -2767605614048989439L;
    private static final int MAX_ARRAY_SIZE = 2147483639;

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

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

    public Vector() {
        this(10);
    }

    public Vector(Collection<? extends E> var1) {
        this.elementData = var1.toArray();
        this.elementCount = this.elementData.length;
        if(this.elementData.getClass() != Object[].class) {
            this.elementData = Arrays.copyOf(this.elementData, this.elementCount, Object[].class);
        }

    }

上面的vector同樣繼承于AbstractList，實現(xiàn)了RandomAccess,Cloneable,Serializable這三個標記接口,默認情況下初始容量也是10，不同于ArrayList的在于多了一個capacityIncrement變量,可以用來指定擴容時容量的增長空間，下面有用到。

Vector中的add操作

public synchronized void addElement(E var1) {
        ++this.modCount;
        this.ensureCapacityHelper(this.elementCount + 1);
        this.elementData[this.elementCount++] = var1;
    }

多了個synchronized修飾符，確保同步安全，調(diào)用了this.ensureCapacityHelper確保容量空間是足夠的,這里的elementCount相當于ArrayList中的size(可能后來設(shè)計ArrayList的時候覺得size比較形象就替換名稱了吧)。

private void ensureCapacityHelper(int var1) {
        if(var1 - this.elementData.length > 0) {
            this.grow(var1);
        }

    }

    private void grow(int var1) {
        int var2 = this.elementData.length;
        int var3 = var2 + (this.capacityIncrement > 0?this.capacityIncrement:var2);
        if(var3 - var1 < 0) {
            var3 = var1;
        }

        if(var3 - 2147483639 > 0) {
            var3 = hugeCapacity(var1);
        }

        this.elementData = Arrays.copyOf(this.elementData, var3);
    }

上面的實現(xiàn)與ArrayList一樣沒什么好說的,區(qū)別在于這里如果指定的擴充容量>0，這時擴充的容量是當前數(shù)組的容量加上capacityIncrement之和的總量,否則就是把當前容量擴大至當前數(shù)組容量的兩倍,如果擴容后仍然小于需要的容量，就把當前的容量大小設(shè)置為需要的容量，最后復制數(shù)組到設(shè)定的總?cè)萘繑?shù)組中。

其他的remove,get等方法與Arraylist的實現(xiàn)基本一致,這里不再贅述。

Stack繼承與Vector它實現(xiàn)了棧操作，先進后出的思想實現(xiàn)。

public class Stack<E> extends Vector<E> {
    private static final long serialVersionUID = 1224463164541339165L;

    public Stack() {
    }

    public E push(E var1) {
        this.addElement(var1);調(diào)用的 Vector.addElement()，添加到尾部
        return var1;
    }

    public synchronized E pop() {
        int var2 = this.size();
        Object var1 = this.peek();調(diào)用peek()獲取最后一個數(shù)據(jù)，最后返回
        this.removeElementAt(var2 - 1);刪除最后一個數(shù)據(jù)元素
        return var1;
    }

    public synchronized E peek() {獲取Vector中最后一個數(shù)據(jù)，但不刪除
        int var1 = this.size();
        if(var1 == 0) {
            throw new EmptyStackException();
        } else {
            return this.elementAt(var1 - 1);
        }
    }

    public boolean empty() {
        return this.size() == 0;
    }

    public synchronized int search(Object var1) {
        int var2 = this.lastIndexOf(var1);
        return var2 >= 0?this.size() - var2:-1;
    }
}

上面的源碼實現(xiàn)比較簡單,上面出現(xiàn)個序列化版本號，這里簡單提下Seriliable是具備繼承性的.
完成入棧/出棧操作的思想是:push的時候把數(shù)據(jù)元素添加到集合尾部,pop的時候獲取集合尾部數(shù)據(jù)并刪除,這樣就實現(xiàn)了基于動態(tài)數(shù)組先進后出的邏輯實現(xiàn)。因為LinkList實現(xiàn)了雙端隊列Deque所以使用LinkList也可以很輕松的完成棧和隊列的實現(xiàn)。詳情見java集合之LinkList解析

上面的方法除了push沒有加synchronized，pop/peek/search都加了synchronized,實現(xiàn)同步操作.

如果沒有線程安全的需求，一般推薦使用 ArrayList，而不是 Vector，因為每次都要頻繁的獲取/釋放鎖操作，效率比較低。