Stack类的介绍

源码分析

package java.util;

/**
 * Stack类表示后进先出,（LIFO）对象堆栈。它使用5个操作扩展了类 Vector，
 * 这些操作允许将向量视为堆栈。提供了通常的 push和 pop操作，
 * 以及在堆栈顶部项目中peek的方法, empty方法表示测试堆栈是否为为空，
 * 以及一种在堆栈中搜索项目的方法，并发现它与顶部的距离。
 * 
 * 首次创建堆栈时，它不包含任何项目.
 *
 * Deque接口及其实现提供了一套更完整，更一致的LIFO堆栈操作，应该优先于此类使用
 * 
 * For example:
 * Deque<Integer> stack = new ArrayDeque<Integer>();
 * 
 */
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:
     * addElement(item)
     */
    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 Vector object).
     * @throws  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 Vector object).
     * @throws  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  true if and only if this stack contains
     *          no items;false otherwise.
     */
    public boolean empty() {
        return size() == 0;
    }

    /**
     * 返回对象在此堆栈上的从1开始的位置。
     * 如果对象o作为此堆栈中的项目出现，则此方法返回距离堆栈顶部最近的出现的堆栈顶部的距离;
     * 堆栈上最顶层的项目被认为是距离1。 
     * equals方法用于将o与此堆栈中的项进行比较。
     *
     * @param   o   期望的对象.
     * @return  从对象所在的堆栈顶部开始的从1开始的位置;
     * 			返回值-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类Demo演示

package cn.com.clearlight.setframe.list.Stack;

import java.util.Stack;

public class StackDemo {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<String>();
        stack.push("a");
        stack.push("b");
        stack.push("d");
        stack.pop(); // 弹栈顶元素"d"
        stack.push("c");

        for (String str : stack) {
            System.out.println(str);
        }
        System.out.println(stack.peek()); // 返回栈顶元素不弹出!
        System.out.println(stack.empty()); // 判断栈是否为空
        System.out.println(stack.search("b")); // 查找元素b在栈中的位置
        System.out.println(stack.search("m")); // 栈中不存在的元素返回-1
    }
}
/*
输出结果:
a
b
c
c
false
2
-1
*/

总结

源码的注释中也说明了,Deque接口及其实现提供了一套更完整，更一致的LIFO堆栈操作，应该优先于此类使用.