Java容器之栈Stack

  栈是一种比较经典的数据结构，遵循LIFO原则,先进栈的元素总是要等到后进栈的元素出栈以后才能出栈，JVM内存划分中其中就有栈区，每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中，而且每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。在Android开发中，如果不使用特殊的Activity启动模式，每次开启一个Activity都会在栈顶加入Activity，点击返回时，之前的Activity就会弹出栈，简单了解下栈的应用后，下面来看Java中的栈:

Java中的栈(Stack)

  如下图所示Stack类的继承关系和实现

1.jpeg

Stack继承于Vector,Stack本身通过扩展Vector而来，而Vector本身是一个可增长的对象数组（ a growable array of objects）那么这个数组的哪里作为Stack的栈顶，哪里作为Stack的栈底?

public class Stack<E> extends Vector<E> {
    /**
     * Creates an empty Stack.
     */
    public Stack() {
    }

    /**
     * Pushes an item onto the top of this stack. This has exactly
     * the same effect as:
     * <blockquote><pre>
     * addElement(item)</pre></blockquote>
     *
     * @param   item   the item to be pushed onto this stack.
     * @return  the <code>item</code> argument.
     * @see     java.util.Vector#addElement
     */
    public E push(E item) {
    addElement(item);

    return item;
    }

    /**
     * Removes the object at the top of this stack and returns that
     * object as the value of this function.
     *
     * @return     The object at the top of this stack (the last item
     *             of the <tt>Vector</tt> object).
     * @exception  EmptyStackException  if this stack is empty.
     */
    public synchronized E pop() {
    E   obj;
    int len = size();

    obj = peek();
    removeElementAt(len - 1);

    return obj;
    }

    /**
     * Looks at the object at the top of this stack without removing it
     * from the stack.
     *
     * @return     the object at the top of this stack (the last item
     *             of the <tt>Vector</tt> object).
     * @exception  EmptyStackException  if this stack is empty.
     */
    public synchronized E peek() {
    int len = size();

    if (len == 0)
        throw new EmptyStackException();
    return elementAt(len - 1);
    }

    /**
     * Tests if this stack is empty.
     *
     * @return  <code>true</code> if and only if this stack contains
     *          no items; <code>false</code> otherwise.
     */
    public boolean empty() {
    return size() == 0;
    }

    /**
     * Returns the 1-based position where an object is on this stack.
     * If the object <tt>o</tt> occurs as an item in this stack, this
     * method returns the distance from the top of the stack of the
     * occurrence nearest the top of the stack; the topmost item on the
     * stack is considered to be at distance <tt>1</tt>. The <tt>equals</tt>
     * method is used to compare <tt>o</tt> to the
     * items in this stack.
     *
     * @param   o   the desired object.
     * @return  the 1-based position from the top of the stack where
     *          the object is located; the return value <code>-1</code>
     *          indicates that the object is not on the stack.
     */
    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;
}

通过peek()方法注释The object at the top of this stack (the last item of the Vector object)，可以发现数组（Vector）的最后一位即为Stack的栈顶
由上边源码可以看出:
pop、peek以及search方法本身进行了同步

push方法调用了父类的addElement方法

empty方法调用了父类的size方法

Vector类为线程安全类

综上，Stack类为线程安全类

Stack简单Demo

public class StackDemo {
    public static void main(String[] args){
        Stack<Integer> stack = new Stack<>();
        push(stack);
        peek(stack);
        search(stack,1);
        pop(stack);
        pop(stack);
        pop(stack);
        pop(stack);
    }

    static void push(Stack stack){
        System.out.println("stack:" + stack);
        for(int i = 0; i < 3; i++){
            stack.push(i);
            System.out.println("push_" + i);
        }
        System.out.println("stack:" + stack);
    }

    static void pop(Stack stack){
        System.out.println("-----------以下是pop操作-----------");

        if (stack.empty()) {
            System.out.println("Stack is empty.");
        } else {
            Integer a = (Integer) stack.pop();
            System.out.println("pop_" + a);
            System.out.println("stack: " + stack);
        }

    }



    static void peek(Stack stack) {
        System.out.println("---------以下是peek操作------------");
        if (stack.empty()) {
            System.out.println("Stack is empty.");
        } else {
            Integer a =  (Integer) stack.peek();
            System.out.println("peek_" + a);
            System.out.println("stack: " + stack);
        }
    }


    static void search(Stack stack, int i) {
        System.out.println("---------以下是search操作------------");
        Integer index = (Integer) stack.search(i);
        System.out.println("index_" + index);
        System.out.println("stack: " + stack);
    }

}

运行结果如下：

stack:[]
push_0
push_1
push_2
stack:[0, 1, 2]
---------以下是peek操作------------
peek_2
stack: [0, 1, 2]
---------以下是search操作------------
index_2
stack: [0, 1, 2]
-----------以下是pop操作-----------
pop_2
stack: [0, 1]
-----------以下是pop操作-----------
pop_1
stack: [0]
-----------以下是pop操作-----------
pop_0
stack: []
-----------以下是pop操作-----------
Stack is empty.

Stack是线程安全的，所以其性能必然受到影响，如果需要使用一个非线程安全的Stack，可以直接使用LinkedList，LinkedList本身提供的方法就包含了Stack的操作。