Vector

vector是jdk1.0引入的，底层实现也是可变长数组，和arraylist类似，其区别如下：

vector是线程安全的，对外暴露的方法几乎都加了sychronized关键字
扩容时默认扩充原数组大小的一倍，而arrayList一次扩容0.5倍

类定义

与arraylist定义一致，继承了abstractList类，实现了list、randomaccess、cloneable、serializable接口。


public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

成员变量

//用于存储数据的数组
   protected Object[] elementData;

//元素个数
   protected int elementCount;

//扩容时增加的容量
   protected int 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;
   }
//传入初始容量，扩容容量默认为0
   public Vector(int initialCapacity) {
       this(initialCapacity, 0);
   }
//初始容量默认为10
   public Vector() {
       this(10);
   }

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

扩容逻辑

//默认最大容量2的31次方-8
   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

   private void grow(int minCapacity) {
       // overflow-conscious code
       int oldCapacity = elementData.length;
//如果扩容增加个数大于0，则一次扩容capacityIncrement个；如果capacityIncrement等于0，则一次扩容原来容量的一倍
       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;
   }

elements

该方法返回一个Enumeration，类似迭代器，区别在于iterator可以修改数据（remove方法），而enumeration不能，iterator支持fail-fast机制，enumerator不支持

public Enumeration<E> elements() {
    return new Enumeration<E>() {
        int count = 0;

        public boolean hasMoreElements() {
            return count < elementCount;
        }

        public E nextElement() {
            synchronized (Vector.this) {
                if (count < elementCount) {
                    return elementData(count++);
                }
            }
            throw new NoSuchElementException("Vector Enumeration");
        }
    };
}

其他

vector其他方法与arraylist类似，但是大部分添加了sychronized关键字进行同步，该类目前已弃用，了解一下就好

Stack

stack类实现了栈的功能，即先进后出，也是线程安全的。

类定义

继承了Vector类

1
2
3


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

重要方法

实现了peek、pop、push等常用方法

//添加元素
   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;
   }