数据结构之堆栈stack

堆栈stack是一种后进先出的通过扩展Vector类而来的数据结构，即先放入的元素在逻辑上处于栈底，而后放入的元素位于栈顶。

常用方法为：push、pop、peek、empty、search等，下面分别列举这些方法：

Stack stack=new Stack();
		
		String ss1="sun";
		String ss2="moon";
		String ss3="star";
		stack.push(ss1);   //把元素压入堆栈
		stack.push(ss2);
		stack.push(ss3);
		System.out.println(stack);  //程序输出：[sun, moon, star]

		stack.pop();	//出栈
		System.out.println(stack);  //程序输出：[sun, moon]
		
		//方法返回栈顶元素，但不做出栈操作
		System.out.println(stack.peek());  //程序输出：moon 

		//方法用来判别堆栈是否为空，
		System.out.println(stack.empty());  //程序输出：false

		//方法返回查找对象的位置。从1开始
		System.out.println(stack.search(ss1)); //程序输出：2 

从jdk1.6的源码来看，stack是继承Vector类的：

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;

细节方面：

1.pop与peek两种方法都返回的是栈顶元素，区别为pop做出栈动作，peek不做。
2.search返回的是与参数equal的与栈顶最近距离的元素与栈顶的距离。

列举各种方法：

package stack;

import java.util.List;
import java.util.Stack;

public class StackTest {
public static void main(String[] args) {
	Stack stack = new Stack();
	stack.push(1);//入栈
	
	System.out.println(stack.isEmpty());//false
	
	stack.pop();//出栈
	System.out.println(stack.isEmpty());//true
	
	stack.push(1);//入栈     int 类型
	stack.push(2l);//入栈     Long类型
	stack.push(3.0);//入栈   double类型
	System.out.println("栈中有： "+stack.size()+" 个元素 。");//栈中有： 3 个元素 。
	
	//栈中可以存放任何类型
	Person p = new Person("xiaoming",20);
	stack.push(p); //入栈  引用对象
	System.out.println("栈中有： "+stack.size()+" 个元素 。");//栈中有： 3 个元素 。
	//System.out.println(stack.get(4)); java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 4
	
	System.out.println(stack.get(3)); // Person [name=xiaoming, age=20]
	System.out.println(stack.peek()); // Person [name=xiaoming, age=20] 取栈顶值（不出栈）
	
	System.out.println(stack.contains(2));//false
	System.out.println(stack.contains(2l));//true
	
	stack.add(2, p); //入栈
	System.out.println(stack.get(2));//Person [name=xiaoming, age=20]
	System.out.println(stack.size());
	
	System.out.println(stack.capacity());// 10
	
	System.out.println(stack.empty());//false 判空
	System.out.println("栈中有： "+stack.size()+" 个元素 。");//栈中有： 5 个元素 。
	
	Stack stack1 = (Stack) stack.clone();//克隆一个栈结构
	System.out.println("克隆的stack1栈中有： "+stack.size()+" 个元素 。");//克隆的stack1栈中有： 5 个元素 。
	System.out.println(stack.equals(stack1));//true
	
	stack.push("你好");
	System.out.println(stack.equals(stack1));//false
	
	System.out.println(stack.elements().toString());//java.util.Vector$1@7852e922
	
	System.out.println("p元素的下标是："+stack.indexOf(p));//p元素的下标是：2
	
	//stack.forEach();
	
	System.out.println(stack.firstElement());//获取栈底元素
	System.out.println(stack.lastElement());//获取栈顶元素
	
	//stack.insertElementAt(1, "hh");
	//stack.notify();有关线程的操作      Exception in thread "main" java.lang.IllegalMonitorStateException
	
	System.out.println("删除之前有"+stack.size()+"个元素"); //删除之前有6个元素
	stack.remove(3);//删除一个元素
	System.out.println("删除一个元素有"+stack.size()+"个元素");//删除之前有5个元素
	
	System.out.println("之前stack1中有"+stack1.size()+"个元素");
	//stack.removeAll(stack1);
	stack1.removeAll(stack1);  //之前stack1中有5个元素     奇怪的用法！！！！！
	System.out.println("removeAll之后，stack1中有"+stack1.size()+"个元素");//removeAll之后，stack1中有0个元素
	
	System.out.println("改变之前，下表为2的元素值为："+stack.get(2));//改变之前，下表为2的元素值为：Person [name=xiaoming, age=20]
	stack.set(2, "改变下标为2的元素");
	System.out.println("改变之后，下表为2的元素值为："+stack.get(2));//改变之后，下表为2的元素值为：改变下标为2的元素
	
	Object[] stackList = stack.toArray();
	for(int i =0;i<stack.size();i++) {
		System.out.print(stackList[i]+",");
	}
	//1,2,改变下标为2的元素,Person [name=xiaoming, age=20],你好,
	
	}
}

参考：
https://blog.csdn.net/a19881029/article/details/9408649
https://blog.csdn.net/IBLiplus/article/details/82505505