Java 7之集合类型 - Vector与Stack

转载地址：http://blog.csdn.net/mazhimazh/article/details/19568867

1、Vector 

Vector类也是基于数组实现的队列，代码与ArrayList非常相似，只不过在可能发生线程安全的方法上加上了Synchornized关键字，使得其执行的效率相比ArrayList就低了。在这个类中有三个重要的变量定义，如下：

[java] view
plaincopyprint?





protected Object[] elementData;  

protected int elementCount;      // 动态数组中存储元素的个数  

protected int capacityIncrement;   

 来解析一下如上两个变量：

 elementData 是"Object[]类型的数组"，它保存了添加到Vector中的元素。elementData是个动态数组，如果初始化Vector时，没指定动态数组的大小，默认大小为10。随着Vector中元素的增加，Vector的容量也会动态增长，capacityIncrement是与容量增长相关的增长系数，具体的增长方式，下面的源码中将分析ensureCapacity()函数。
 capacityIncrement 是动态数组的增长系数。如果在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量增加时，增加的大小都是capacityIncrement。

看一下两个最主要的构造函数：

[java] view
plaincopyprint?





// capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。  

public Vector(int initialCapacity, int capacityIncrement) {  

    super();  

    if (initialCapacity < 0)  

        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  

    this.elementData = new Object[initialCapacity];  

    this.capacityIncrement = capacityIncrement;  

}  

// 创建一个包含collection元素的Vector  

public Vector(Collection<? extends E> c) {  

    elementData = c.toArray();  

    elementCount = elementData.length;  

    // c.toArray might (incorrectly) not return Object[] (see 6260652)  

    if (elementData.getClass() != Object[].class)  

        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);  

}  

看一下动态扩容的相关函数源代码实现：

[java] view
plaincopyprint?





private void ensureCapacityHelper(int minCapacity) {  

     if (minCapacity - elementData.length > 0)  

         grow(minCapacity);  

 }  

   

 private void grow(int minCapacity) {  

  

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

 }  

在进行动态扩容时，Vector的新容量大小为原有容量加上capacityIncrement，如果这个数不大于0，则扩容为原始容量的2倍。

下面为总结一下ArrayList和Vector的区别：

ArrayList在内存不中时扩容的策略为50% + 1个，Vector在capacityIncrement大于0时扩容capacityIncrement大小，否则为原始容量（oldCapacity）的2倍。
Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销。Vector这种安全也是相对的，为什么这么说呢？请看下面的例子：

[java] view
plaincopyprint?





public class VectorTest {  

   

    private static Vector v = new Vector();  

   

    public static void readAll() {  

        int size = v.size();  

        for (int i = 0; i < size; i++) {  

            v.get(i);  

        }  

    }  

   

    public static void deleteAll() {  

        if (v.iterator().hasNext()) {  

            v.remove(0);  

        }  

    }  

}  

如上的程序在执行的过程中就有可能招出ArrayIndexOutOfBoundException异常。

2、Stack

Stack是栈。它的特性是：先进后出(FILO, First In Last Out)。Stack是继承于Vector(矢量队列)的，由于Vector是通过数组实现的，这就意味着，Stack也是通过数组实现的。其类的源代码如下：

[java] view
plaincopyprint?





public class Stack<E> extends Vector<E> {  

    public Stack() {    }  

    public E push(E item) {       // 压栈  

        addElement(item);  

  

        return item;  

    }  

  

    public synchronized E pop() { // 弹栈  

        E   obj;  

        int  len = size();  

        obj = peek();  

        removeElementAt(len - 1);  

  

        return obj;  

    }  

  

    public synchronized E peek() { // 返回栈顶元素  

        int  len = size();  

        if (len == 0)  

            throw new EmptyStackException();  

        return elementAt(len - 1);  

    }  

  

    public boolean empty() {      // 判断栈是否为空  

        return size() == 0;  

    }  

  

    public synchronized int search(Object o) {  // 查找元素  

        int i = lastIndexOf(o);  

        if (i >= 0) {  

            return size() - i;  

        }  

        return -1;  

    }  

  

}