java.util.Stack类简介

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

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

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

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

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

  1. public class Stack<E> extends Vector<E> {
  2. /**
  • * 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类为线程安全类(多个方法调用而产生的数据不一致问题属于原子性问题的范畴)

    • public class Test {
    • public static void main(String[] args) {
    • Stack<String> s = new Stack<String>();
  • System.out.println("------isEmpty");
    • System.out.println(s.isEmpty());
    • System.out.println("------push");
    • s.push("1");
    • s.push("2");
    • s.push("3");
    • Test.it(s);
    • System.out.println("------pop");
    • String str = s.pop();
    • System.out.println(str);
    • Test.it(s);
    • System.out.println("------peek");
    • str = s.peek();
    • System.out.println(str);
    • Test.it(s);
    • System.out.println("------search");
    • int i = s.search("2");
    • System.out.println(i);
    • i = s.search("1");
    • System.out.println(i);
    • i = s.search("none");
    • System.out.println(i);
    • }
    • public static void it(Stack<String> s){
    • System.out.print("iterator:");
    • Iterator<String> it = s.iterator();
    • while(it.hasNext()){
    • System.out.print(it.next()+";");
    • }
    • System.out.print("\n");
    • }
      • 结果:
        • ------isEmpty
        • true
        • ------push
        • iterator:1;2;3;
        • ------pop
        • 3       --栈顶是数组最后一个
        • iterator:1;2;
        • ------peek
        • 2       --pop取后删掉,peek只取不删
        • iterator:1;2;
        • ------search
        • 1       --以1为基数,即栈顶为1
        • 2       --和栈顶见的距离为2-1=1
        • -1      --不存在于栈中
        • Stack并不要求其中保存数据的唯一性,当Stack中有多个相同的item时,调用search方法,只返回与查找对象equal并且离栈顶最近的item与栈顶间距离(见源码中search方法说明)
时间: 2024-11-01 18:01:11

java.util.Stack类简介的相关文章

java.util.Stack类中的peek()方法

java.util.stack类中常用的几个方法:isEmpty(),add(),remove(),contains()等各种方法都不难,但需要注意的是peek()这个方法. peek()查看栈顶的对象而不移除它. import java.util.Stack; public class MyStack1 { private Stack<Integer> stackData; private Stack<Integer> stackMin; public MyStack1(){ t

Java中的栈:java.util.Stack类

public class Stack<E>extends Vector<E>Stack 类表示后进先出(LIFO)的对象堆栈.它通过五个操作对类 Vector 进行了扩展 ,允许将向量视为堆栈.它提供了通常的 push 和 pop 操作,以及取堆栈顶点的 peek 方法.测试堆栈是否为空的 empty 方法.在堆栈中查找项并确定到堆栈顶距离的 search 方法.  方法 使用说明 boolean empty() 测试堆栈是否为空 E peek() 查看堆栈顶部的对象,但不从堆栈移

恶补java(十一)-------Stack类的使用

package com.gc.Stack; /** * java中stack的使用方法,堆栈是一种"后进先出"(LIFO)的数据结构,只能在一端进行插入(称为"压栈")或删除(称为"出栈")数据的操作. * Java中,使用java.util.Stack类的构造方法创建对象 * public class Stack extends vector * 构造方法:public Stack()创建一个空Stack * 1.public push(ite

java.util.Properties类

Properties类很常用么,几乎每个项目,从j2se到j2ee每个项目都没离开过他,就算是jsp+servlet+jdbc的东西,jdbc的配置信息也是写Properties,国际化也是Properties,cdn也是Properties,memcached也是 Properties.总之java.utils.*无所不用,不所不在.. 小记下Properties: java.util.Properties是对properties这类配置文件的映射.支持key-value类型和xml类型两种.

java.util.Random 类的 nextInt(int num )

随机产生3个67~295的整数并找出数值居中的数 并输出中间的数例如:100,225和200,输出200 要随机产生某个范围内的整数,用 java.util.Random 类的 nextInt(int num) 最简洁. nextInt( int num) 能接受一个整数作为它所产生的随机整数的上限,下限为零,比如:nextInt(4)将产生0,1,2,3这4个数字中的任何一个数字,注意这里不是0-4,而是0-3..但下限总是零,不能更改,所以若要达到非零下限的效果,必须把上限减去下限的结果传给

字符串转换成java.util.date类型和将java.util.date类型转换成java.sql.date类型

//将字符串转换成java.util.date类型 DateFormat format = new SimpleDateFormat("yyyyMMDD"); Date date1 = format.parse(startDate); //将java.util.date类型转换成java.sql.date类型 skg.statStartTime = new java.sql.Date(date1.getTime()); skg.statEndTime = new java.sql.Da

java.util.Arrays类

java.util.Arrays类能方便的操作数组,它所有的方法都是静态的. 1.filll方法 :给数组中的某段元素附上相同值. 2.sort方法:对数组中某段元素排序. 3.equals方法:比较两个数组,判断的是数组中元素值是否相等. 4.binarySearch方法:对排过序的数组进行二分法查找. 不错的例子: /*-------文件名: UsingArrys.java-------*/ package com.sjx.test; import java.util.Arrays; /**

java.util.Arrays类详解

为实现数组的排序和查找.数组的比较和对数组填充元素,java.util.Arrays类包括各种各样的静态方法.这些方法都有对所有基本类型的重载方法. 可以使用sort方法对整个数组或部分数组进行排序.例如,下面的代码对数值型数组和字符型数组进行排序. double[] numbers = {6.0,4.4,1.9,2.9,3.4,3.5}; java.util.Arrays.sort(numbers);最后的结果是[1.9, 2.9, 3.4, 3.5, 4.4, 6.0]默认为升序排列 cha

java.util.Properties类 学习笔记

学习目标: 1.认识properties文件,理解其含义,会正确创建properties文件. 2.会使用java.util.Properties类来操作properties文件. 3.掌握相对路径,能正确书写一个properties文件的相对路径. 一.认识properties文件 1.properties文件是一个文本文件 2.properties文件的语法有两种,一种是注释,一种属性配置. 注    释:前面加上#号 属性配置:以“键=值”的方式书写一个属性的配置信息. 3.propert