Java 堆栈使用最后一个推送的元素替换其中的所有条目

这件事我需要一些帮助，因为我在任何地方都找不到合乎逻辑的解释。也许这只是一个小错误，但我已经在代码这么长时间，我只是看不到它。我添加了一些注释，试图在堆栈中推送元素。我有两个堆栈，一个用于所有运算符，一个用于操作数。运算符堆栈工作正常，但操作数堆栈的行为异常。当我尝试推送元素时，它会以某种方式用我推送的最新元素替换堆栈元素。当我弹出时，它始终返回最后一个元素。我有两个不同的类作为运算符和操作数。如果你需要密码，请告诉我。EDIT：其他类没有做什么，尽管只是几个getter、setter和检查令牌的有效性。感谢您的帮助。谢谢

   import java.util.*;
   public class Evaluator {
private Stack<Operand> opdStack;
private Stack<Operator> oprStack;
public Evaluator() {
    opdStack = new Stack<Operand>();
    oprStack = new Stack<Operator>();
// HashMap<String, Operator> operators = new HashMap<String, Operator>();

        Operator.operators.put("+",new AdditionOperator());
        Operator.operators.put("-", new SubtractionOperator());
        Operator.operators.put("*",new MultiplyOperator());
        Operator.operators.put("/",new DivisionOperator());
        Operator.operators.put("#",new BogusHash());

}

public int eval(String expr) {
    String tok = "";
    // init stack - necessary with operator priority schema;
    // the priority of any operator in the operator stack other then
    // the usual operators - "+-*/" - should be less than the priority
    // of the usual operators 

    Operator newOpr = Operator.operators.get("#");

    oprStack.push(newOpr); 

    String delimiters = "+-*/#! ";
    StringTokenizer st = new StringTokenizer(expr,delimiters,true);
    // the 3rd arg is true to indicate to use the delimiters as tokens, too
    // but we'll filter out spaces
    while (st.hasMoreTokens()) {
        if ( !(tok = st.nextToken()).equals(" ")) { // filter out spaces
            //System.out.println("equals");
            if (Operand.check(tok)) { // check if tok is an operand
                //System.out.println("tokens = "+tok);
                //opdStack.push(new Operand ("0"));

                opdStack.push(new Operand(tok));
                System.out.println("stack peek "+ opdStack.peek().getValue());

                //System.out.println(opdStack);
                //System.out.println(oprStack);

            } else {
                //System.out.println("tokens = "+tok);
                //System.out.println(newOpr);

                if (!Operator.operators.containsKey(tok)) {
                    //System.out.println("tokens = "+tok);
                    //System.out.println(newOpr);
                    System.out.println("*****invalid token******"); System.exit(1);
                }
                Operator newOpr2 = Operator.operators.get(tok); // POINT 1
                //System.out.println("Operator = "+oprStack.peek().priority());
                while ( (oprStack.peek()).priority() >= newOpr2.priority()) {
                    //System.out.println("tokens while = "+tok);

                    System.out.println("tokens = "+tok);
                    Operator oldOpr = ((Operator)oprStack.pop());
                    //System.out.println("Opr"+oldOpr.priority());
                    Operand op2 = (Operand)opdStack.pop();

                    Operand op1 = (Operand)opdStack.pop();
                    System.out.println("run till here");
                    opdStack.push(oldOpr.execute(op1,op2));


                    System.out.println("Final res pushed opd= " + opdStack.peek().getValue());
                }
                oprStack.push(newOpr2);
                //System.out.println("operand "+opdStack.toString());

            }

        }




    }

    //System.out.println("pop op2 = "+opdStack.pop().getValue()+" and pop op1 = "+opdStack.pop().getValue());
    Operator newOp2 = ((Operator)oprStack.pop());
    Operand op2 = (Operand)opdStack.get(0);
    Operand op1 = (Operand)opdStack.get(1);
    System.out.println("opd = "+ op1.getValue() + op2.getValue());
    opdStack.push(newOp2.execute(op2, op1));

    System.out.println("Full Stack opd size= "+ opdStack.size());

    //System.out.println("Full Stack opd= "+ opdStack.toString());

    Operand res = (Operand) opdStack.pop();



    return res.getValue();

   }
  }

---

你能解释一下什么不起作用，而不是说它的行为很奇怪吗？它的作用是，当我尝试弹出堆栈的元素时，它返回最后一个一直按下的元素。编辑：所以当我尝试执行时，它使用最后一个弹出的元素两次并给出结果。是的，因为它是一个堆栈。堆栈是后进先出（last-in-first-out），意思是它将对象放在顶部，并从顶部提取。比如一堆盘子。推到堆栈上的最后一块板是第一块板。请尝试通过while循环进行调试。看来这就是烟囱拆除的地方occurs@Jean-弗朗索瓦·萨瓦德：是的，但在它删除之后，应该删除下一个元素。我的堆栈多次检索同一元素。即使在弹出一次之后，它下面也有相同的元素。

 public class Operand {

 static int val=0;
private static String strval="";
public Operand(String tok) {
    // TODO Auto-generated constructor stub
     strval = tok;
     val = Integer.parseInt(strval);
    // System.out.println("value = "+val);
}

public Operand(int value){
    val = value;
    //System.out.println("value = "+val);
}

public static boolean check(String tok) {
    // TODO Auto-generated method stub
    boolean bool;
    try {
        Integer.parseInt(tok);
        bool = true;
    } catch (Exception e){
        //System.out.println("Type conversion "+e);
        bool = false;
    }
    return bool;
}

public int getValue(){
    //int re = Integer.parseInt(this.toString());
    System.out.println("return value = " + val);
    return val;

}
}