java.util.Stack类简介

Stack

Stack是一个后进先出(last in first out,LIFO)的堆栈,在Vector类的基础上扩展5个方法而来

Deque(双端队列)比起Stack具有更好的完整性和一致性,应该被优先使用

[plain]  view plain copy
  1. E push(E item)   
  2.          把项压入堆栈顶部。   
  3. E pop()   
  4.          移除堆栈顶部的对象,并作为此函数的值返回该对象。   
  5. E peek()   
  6.          查看堆栈顶部的对象,但不从堆栈中移除它。   
  7. boolean empty()   
  8.          测试堆栈是否为空。    
  9. int search(Object o)   
  10.          返回对象在堆栈中的位置,以 1 为基数。  

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

答案只能从源代码中寻找,jdk1.6:

[java]  view plain copy
  1. public class Stack extends Vector {  
  2.     /** 
  3.      * Creates an empty Stack. 
  4.      */  
  5.     public Stack() {  
  6.     }  
  7.   
  8.     /** 
  9.      * Pushes an item onto the top of this stack. This has exactly 
  10.      * the same effect as: 
  11.      * 
     
  12.      * addElement(item) 
  13.      * 
  14.      * @param   item   the item to be pushed onto this stack. 
  15.      * @return  the item argument. 
  16.      * @see     java.util.Vector#addElement 
  17.      */  
  18.     public E push(E item) {  
  19.     addElement(item);  
  20.   
  21.     return item;  
  22.     }  
  23.   
  24.     /** 
  25.      * Removes the object at the top of this stack and returns that 
  26.      * object as the value of this function. 
  27.      * 
  28.      * @return     The object at the top of this stack (the last item 
  29.      *             of the Vector object). 
  30.      * @exception  EmptyStackException  if this stack is empty. 
  31.      */  
  32.     public synchronized E pop() {  
  33.     E   obj;  
  34.     int len = size();  
  35.   
  36.     obj = peek();  
  37.     removeElementAt(len - 1);  
  38.   
  39.     return obj;  
  40.     }  
  41.   
  42.     /** 
  43.      * Looks at the object at the top of this stack without removing it 
  44.      * from the stack. 
  45.      * 
  46.      * @return     the object at the top of this stack (the last item 
  47.      *             of the Vector object). 
  48.      * @exception  EmptyStackException  if this stack is empty. 
  49.      */  
  50.     public synchronized E peek() {  
  51.     int len = size();  
  52.   
  53.     if (len == 0)  
  54.         throw new EmptyStackException();  
  55.     return elementAt(len - 1);  
  56.     }  
  57.   
  58.     /** 
  59.      * Tests if this stack is empty. 
  60.      * 
  61.      * @return  true if and only if this stack contains 
  62.      *          no items; false otherwise. 
  63.      */  
  64.     public boolean empty() {  
  65.     return size() == 0;  
  66.     }  
  67.   
  68.     /** 
  69.      * Returns the 1-based position where an object is on this stack. 
  70.      * If the object o occurs as an item in this stack, this 
  71.      * method returns the distance from the top of the stack of the 
  72.      * occurrence nearest the top of the stack; the topmost item on the 
  73.      * stack is considered to be at distance 1. The equals 
  74.      * method is used to compare o to the 
  75.      * items in this stack. 
  76.      * 
  77.      * @param   o   the desired object. 
  78.      * @return  the 1-based position from the top of the stack where 
  79.      *          the object is located; the return value -1 
  80.      *          indicates that the object is not on the stack. 
  81.      */  
  82.     public synchronized int search(Object o) {  
  83.     int i = lastIndexOf(o);  
  84.   
  85.     if (i >= 0) {  
  86.         return size() - i;  
  87.     }  
  88.     return -1;  
  89.     }  
  90.   
  91.     /** use serialVersionUID from JDK 1.0.2 for interoperability */  
  92.     private static final long serialVersionUID = 1224463164541339165L;  
  93. }  

通过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类为线程安全类(多个方法调用而产生的数据不一致问题属于原子性问题的范畴)

[java]  view plain copy
  1. public class Test {  
  2.     public static void main(String[] args) {  
  3.         Stack s = new Stack();  
  4.         System.out.println("------isEmpty");  
  5.         System.out.println(s.isEmpty());  
  6.         System.out.println("------push");  
  7.         s.push("1");  
  8.         s.push("2");  
  9.         s.push("3");  
  10.         Test.it(s);  
  11.         System.out.println("------pop");  
  12.         String str = s.pop();  
  13.         System.out.println(str);  
  14.         Test.it(s);  
  15.         System.out.println("------peek");  
  16.         str = s.peek();  
  17.         System.out.println(str);  
  18.         Test.it(s);  
  19.         System.out.println("------search");  
  20.         int i = s.search("2");  
  21.         System.out.println(i);  
  22.         i = s.search("1");  
  23.         System.out.println(i);  
  24.         i = s.search("none");  
  25.         System.out.println(i);  
  26.     }  
  27.       
  28.     public static void it(Stack s){  
  29.         System.out.print("iterator:");  
  30.         Iterator it = s.iterator();  
  31.         while(it.hasNext()){  
  32.             System.out.print(it.next()+";");  
  33.         }  
  34.         System.out.print("\n");  
  35.     }  
  36. }  

结果:

[sql]  view plain copy
  1. ------isEmpty  
  2. true            
  3. ------push  
  4. iterator:1;2;3;    
  5. ------pop  
  6. 3       --栈顶是数组最后一个  
  7. iterator:1;2;  
  8. ------peek  
  9. 2       --pop取后删掉,peek只取不删  
  10. iterator:1;2;  
  11. ------search      
  12. 1       --以1为基数,即栈顶为1  
  13. 2       --和栈顶见的距离为2-1=1  
  14. -1      --不存在于栈中  

Stack并不要求其中保存数据的唯一性,当Stack中有多个相同的item时,调用search方法,只返回与查找对象equal并且离栈顶最近的item与栈顶间距离(见源码中search方法说明)

 

你可能感兴趣的:(数据结构)