Java 中缀表达式解算器中出现空堆栈异常

所以我的程序应该采用语法正确的中缀表达式 包含GUI中的整数操作数和四个算术运算符（+-*/），并显示结果。不幸的是，如果我输入一个简单的表达式，比如3+4，程序就会抛出一个空堆栈异常。我刚刚开始使用stacks，所以请原谅我犯了一些简单的错误。请帮忙

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;


public class inFix extends JFrame
{
   private Container contents;
   private JLabel infixLabel, resultLabel, result;
   private JTextField infixText;
   private JButton evaluate;

   public inFix()
   {
      super("Infix Expresion Evaluator");
      contents = getContentPane();
      contents.setLayout( new FlowLayout() );

      infixLabel = new JLabel("Enter Infix Expression:");
      infixText = new JTextField("", 14);

      evaluate = new JButton("Evaluate");

      resultLabel = new JLabel("Result:");
      result = new JLabel("???");

      contents.add( infixLabel );
      contents.add( infixText );
      contents.add( evaluate );
      contents.add( resultLabel );
      contents.add( result );


      ButtonHandler bh = new ButtonHandler();

      evaluate.addActionListener( bh );

      setSize( 350, 200 );
      setVisible( true );
   }

   private class ButtonHandler implements ActionListener
   {
      public void actionPerformed( ActionEvent ae )
      {
         result.setText(infix(infixText.getText()));
      }
   }


   public String infix(String expression)
   {
      expression=expression.replaceAll("[\t\n ]", "")+"=";
      String operator = "*/+-";
      int value1, value2;
      char ch;
      StringTokenizer tokenizer = new StringTokenizer(expression, operator, true); 
      Stack<Integer> valueStack = new Stack<Integer>();
      Stack<Character> operatorStack = new Stack<Character>();

      while(tokenizer.hasMoreTokens())
      {
         String token = tokenizer.nextToken();
         if(isInteger(token) == true)
            valueStack.push(Integer.parseInt(token));
         else if(token.charAt(0) == '(')
            operatorStack.push(token.charAt(0));
         else if(token.charAt(0) == ')')
            while(operatorStack.peek() != '(')
            {
               value1 = valueStack.pop();
               value2 = valueStack.pop();
               valueStack.push(solver(value1, value2, operatorStack.pop()));
            }
         else if(token.charAt(0) == '+' || token.charAt(0) == '-' || token.charAt(0) == '*' || token.charAt(0) == '/')
         {
            while(!operatorStack.isEmpty() && precedence(token.charAt(0)) <= precedence(operatorStack.peek()))
            {
               value1 = valueStack.pop();
               value2 = valueStack.pop();
               valueStack.push(solver(value1, value2, token.charAt(0)));
            }
            operatorStack.push(token.charAt(0));
         }
      }
      while(!operatorStack.isEmpty())
      {
         value1 = valueStack.pop();
         value2 = valueStack.pop();
         ch = operatorStack.pop();
         valueStack.push(solver(value1, value2, ch));
      }


      String result = Integer.toString(valueStack.pop());
      return result;     
   }

   public static boolean isInteger(String s)
   {
      try
      { 
         Integer.parseInt(s);
      } 
      catch(NumberFormatException e)
      {
         return false; 
      } 
      catch(NullPointerException e) 
      {
         return false;
      }
      return true;
   }
   public int solver( int value1, int value2, char operator)
   {
      if(operator == '*')
         return value1 * value2;
      else if(operator == '/')
         return value1 / value2;
      else if(operator == '+')
         return value1 + value2;
      else if(operator == '-')
         return value1 - value2;
      else
         return 0;
   }

   public int precedence(char op)
   {
      if(op == '+' || op == '-')
         return 1;
      else if(op == '*' || op == '/')
         return 2;
      else
         return -1;
   }   


   public static void main( String [] args )
   {
      inFix infixsolver = new inFix();
      infixsolver.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

}

import javax.swing.*；
导入java.awt.*；
导入java.awt.event.*；
导入java.util.*；
公共类中缀扩展JFrame
{
私家货柜内容物；
私有JLabel infixLabel，resultLabel，result；
私有JTextField-infixText；
私有JButton评价；
公共中缀（）
{
超级（“中缀表达式求值器”）；
contents=getContentPane（）；
contents.setLayout（新的FlowLayout（））；
infixLabel=newjlabel（“输入中缀表达式：”）；
infixText=新的JTextField（“，14）；
evaluate=新的JButton（“evaluate”）；
resultLabel=新的JLabel（“结果：”）；
结果=新的JLabel（“？？？”）；
contents.add（infixLabel）；
contents.add（infixText）；
内容。添加（评估）；
contents.add（resultLabel）；
内容。添加（结果）；
ButtonHandler bh=新ButtonHandler（）；
evaluate.addActionListener（bh）；
设置大小（350200）；
setVisible（真）；
}
私有类ButtonHandler实现ActionListener
{
已执行的公共无效行动（行动事件ae）
{
result.setText（infix（infixText.getText（））；
}
}
公共字符串中缀（字符串表达式）
{
expression=expression.replaceAll（“[\t\n]”，“）+”=”；
字符串运算符=“*/+-”；
int值1、值2；
char ch；
StringTokenizer tokenizer=新的StringTokenizer（表达式，运算符，true）；
堆栈值堆栈=新堆栈（）；
堆栈运算符堆栈=新堆栈（）；
while（tokenizer.hasMoreTokens（））
{
String token=tokenizer.nextToken（）；
如果（isInteger（令牌）=真）
push（Integer.parseInt（token））；
else如果（token.charAt（0）='（'）
运算符stack.push（令牌字符（0））；
else if（token.charAt（0）='）'）
while（运算符stack.peek（）！='（'）
{
value1=valueStack.pop（）；
value2=valueStack.pop（）；
valueStack.push（解算器（value1、value2、operatorStack.pop（））；
}
else if（token.charAt（0）='+'| | token.charAt（0）='-'| | token.charAt（0）='*'.| | token.charAt（0）='/'））
{
而（！operatorStack.isEmpty（）&&priority（token.charAt（0））假设输入表达式为“3+4”
在线54

expression=expression.replaceAll("[\t\n ]", "")+"=";

expression=expression.replaceAll("[\t\n ]", "")+"=";

表达式变成“3+4=”
在标记器操作之后，标记为[“3”、“+”、“4=”]，这会在第65行为标记“4=”生成错误结果

if(isInteger(token) == true)

因此，当您在第89行弹出时，值的数量是不够的

     value2 = valueStack.pop();

要解决此问题，请删除第54行中的+“=”