Java之--Stack栈

Stack栈
====================================================
【后进先出】的结构

Stack本身通过扩展Vector而来，而Vector本身是一个可增长的对象数组（a growable array of objects）

栈的数组结构实现

jdk1.7(其它版本可能不同)
---------------------------------------------------------
Stack.class   5个方法
E push(E item)             把项压入栈顶部。            
E pop()                           移除栈顶部的对象，并作为此函数的值返回该对象。          
E peek()                         查看栈顶部的对象，但不从堆栈中移除它。         
boolean empty()           测试栈是否为空。            
int search(Object o)     返回对象在栈中的位置，以1为基数。      
---------------------------------------------------------
public class Stack<E> extends Vector<E>{}

public class Vector<E> extends AbstractList<E> implements List<E>, ...{
    protected Object[] elementData;     //数组
    protected int elementCount;             //数组中元素个数
    protected int capacityIncrement;      //自动递增量(大小)
}

0.初始化
Stack stack = new Stack();//就这一个构造方法
会调用Vector的构造方法,Vector线程安全
public Vector() {
    this(10);
}
public Vector(int initialCapacity, int capacityIncrement) {
    this.elementData = new Object[initialCapacity];     //初始容量为10
    this.capacityIncrement = capacityIncrement;          //初始递增量为0
}



1.push()把对象压入栈顶
public E push(E item) {
       addElement(item);
        return item;
}
public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);//确保需不需要扩容
        elementData[elementCount++] = obj;//elementCount++数组中元素个数加1；加入的数据依次往后放
}
private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)//大于数组中元素个数时扩容
            grow(minCapacity);//扩容
}

//Stack stcapacityIncrement=0，扩容量为原来的一倍
//原来elementData.length=10，扩容后为20，再扩容后为40
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);//如果capacityIncrement=0，扩容量为原来的一倍
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
}

2.pop()移除栈顶部的对象
public synchronized E pop() {
        E obj = peek();//栈顶对象
        removeElementAt(size() - 1);//移除栈顶对象

        return obj;//返回栈顶对象
    }
public synchronized void removeElementAt(int index) {
      ......  
        elementCount--;
        elementData[elementCount] = null;
    }

3.peek()查看栈顶部的对象
//return the object at the top of this stack (the last item of the Vector object).
public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }
相当于 elementData[size() - 1]

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

5. search()返回对象在栈中的位置
public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;//对象在栈中的位置，以1为基数；从栈顶到栈底的顺序
        }
        return -1;
    }
public synchronized int lastIndexOf(Object o, int elementCount-1) {
        ......
        for (int i = index; i >= 0; i--)//从数组后面往前找(相当于从栈顶往栈底找)
            if (o.equals(elementData[i]))
               return i;
        
        return -1;
    }

Stack不要求其中保存数据的唯一性，当Stack中有多个相同的item时，调用search方法，

只返回与查找对象equal并且离栈顶最近的item与栈顶间距离