Java容器学习--Vector&Stack源码分析

Vector

Vector 是可变长的数组，它是 JDK1.0 版本添加的类。继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。
Vector 继承了 AbstractList ，实现了 List ；所以，它是一个列表容器，支持相关的添加、删除、修改、遍历等功能。
Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。
Vector 实现了 Cloneable 接口，即实现 Object.clone() 函数。它能被克隆。

和 ArrayList 不同，Vector 中的操作是线程安全的。

属性

// 存储向量组件的数组缓冲区
// vector 的容量就是此数据缓冲区的长度，该长度至少要足以包含向量的所有元素
// Vector 中的最后一个元素后的任何数组元素都为 null
protected Object[] elementData;
// Vector 对象中的有效组件数
// 从 elementData[0] 到 elementData[elementCount-1] 的组件均为实际项
protected int elementCount;
// 向量的大小大于其容量时，容量自动增加的量
// 如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍
protected int capacityIncrement;
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -2767605614048989439L;

构造方法

// 使用指定的初始容量和容量增量构造一个空的向量
// initialCapacity: 向量的初始容量
// capacityIncrement: 当向量溢出时容量增加的量
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);            
}                        

// 构造一个包含指定 collection 中的元素的向量
// 这些元素按其 collection 的迭代器返回元素的顺序排列
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);
}                                                                                                                                                         

Vector中的大部分函数实现和ArrayList中的大致一致。

---

Stack

Stack 是栈。
它的特性是：先进后出(FILO, First In Last Out)。
Stack 继承于 Vector，所以它的实现也是基于数组。
Java已经不再推荐使用Stack，而优先使用 LinkedList 与 ArrayDeque。以上两个实现也都支持栈的操作。LinkedList基于链表；ArrayDeque基于循环队列。

public class Stack<E> extends Vector<E> {
    /**
     * 创建一个空堆栈
     */
    public Stack() {
    }

    /**
     * 把项压入堆栈顶部。其作用与下面的方法完全相同：
     * addElement(item)
     */
    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;
    }

    /**
     * 返回对象在堆栈中的位置，以 1 为基数
     * 如果对象 o 是堆栈中的一个项，此方法返回距堆栈顶部最近的出现位置到堆栈顶部的距离
     * 堆栈中最顶部项的距离为 1。使用 equals 方法比较 o 与堆栈中的项
     * 说白了就是查找元素o在栈中的位置，栈顶元素索引为1
     */
    public synchronized int search(Object o) {
        int i = lastIndexOf(o);
        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}

Stack 操作（添加、删除、获取）的元素只能是位于栈顶。