JDK1.8之Vector&Stack源码分析

一、Vector和Stack简单介绍

 Vector和ArrayList一样，均是属于List的实现类，现在我们主要说明两者的异同点及和Stack的关系；让我们能够更加清晰的认识该集合类型。

    相同点：

        1、均是List集合的实现类

        2、底层数据存储结构 Objcet 类型的数组

   不同点：

        1、ArrayList的容量大小的怎长策略不同，ArrayList在无参数构造时候容量为0，后面调用add(E e)方法时候通过容量判断给定初始值为10，而Vector在无参初始化时候就给定初始容量大小为10

        2、在调用add(E e)添加元素时候均调用ensureCapacityHelper（int minCapacity）方法判断容量是否足够，但是对于容量不足后两者怎长策略不一样，ArrayLis为增长为1.5倍(oldLength+oldLength>>1)；而Vector增长为2培(oldLength+oldlength)

       3、在方法上，Vector供外部类访问的方法均是synchronized修饰属于线程安全的，而ArrayList没有

  而对于Stack而言，它是Vector的子类，还提供了LIFO（last in first out）后进先出的数据结构特点

   二、Vector源码分析

     1、重要属性和构造函数

     //存储数据的数组

    protected Object[] elementData;

    //元素的个数
    protected int elementCount;

   //增加的容量
    protected int capacityIncrement;
    //序列化版本号
    private static final long serialVersionUID = -2767605614048989439L;

      //根据给定的容量和增长容量初始化容器

     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  增量为0
    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、主要方法，因为和ArrayList方法类似，我们只需要看add()即可，对比两者之间的增长策略

    public synchronized boolean add(E e) {

        //操作次数记录

        modCount++;

         //判断容量是否足够

        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

   

 private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code

        if (minCapacity - elementData.length > 0)

            grow(minCapacity);//增长策略函数
    }

  private void grow(int minCapacity) {
        // overflow-conscious code

        int oldCapacity = elementData.length;

         // 如果增长capacityIncrement ！=0怎容量为 oldCapacity+增长容量

      //如果增长capacityIncrement值为0，容量大小增长为原来2倍

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

    }

  //对比ArrayList的增长策略

    private void grow(int minCapacity) {
        // overflow-conscious code

        int oldCapacity = elementData.length;

         //增长为原来的1.5倍

        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);

    }

 其他方法与ArrayList类似，我们就不在讨论，下面我们分析Stack中实现FIFO的几个方法源码

三、Stack源码分析

package java.util;
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() { //出栈，返回栈顶元素，栈顶指针-1
        int     len = size();
        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }
    public boolean empty() { //栈内元素个数 调用父类的size()方法
        return size() == 0;  
    }
    public synchronized int search(Object 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内部一共五个方法，其中三个方法都加了synchronized关键字，是线程安全的，而push和empty方法调用了Vector的方法，由于Vector中的addElement()和size()方法都是线程安全的，所以Stack的每个方法也都是线程安全的，所以它和Vector一样，都是线程安全的。根据执行流程我们可以知道Stack的初始容量也为10

总结

Vector与ArrayList的最大区别就是Vector是线程安全的，而ArrayList不是线程安全的。另外区别还有： 
- ArrayList不可以设置扩展的容量，默认1.5倍；Vector可以设置扩展的容量，如果没有设置，默认2倍 
- ArrayList的无参构造方法中初始容量为0，而Vector的无参构造方法中初始容量为10。 

- Vector线程安全，ArrayList线程不安全。

-Stack的初始容量也为10

Vector和它的子类Stack都是线程安全的集合。