表达式树在大于9的数字下无法正常工作

Question

我正在完成一个表达式树程序，它接受一个后缀并以中缀形式给出答案和原始方程。我大约6个月前开始工作，并且遇到了一个我无法弄清楚的问题。如果数字小于9，它工作正常。例如，2 5 * 4 - 打印出中缀：（2 * 5-4）6.0工作正常。类似10 2 *的东西打印出20.0但是打印出中缀：（0 * 2）这是不对的。最大的问题是，如果一个数字大于9，它就不能正确地读取该数字，这会将转换混淆为中缀。我不确定如何解决这个问题。以下是我的班级和测试员班级：

 import java.util.NoSuchElementException;
 import java.util.Stack;
public class ExpressionTree 
{      

private final String postfix;
private TreeNode root;

/**
 * Takes in a valid postfix expression and its used to construct the expression tree.

 */
public ExpressionTree(String postfix) 
{
    if (postfix == null) { throw new NullPointerException("The posfix should not be null"); }
    if (postfix.length() == 0)  { throw new IllegalArgumentException("The postfix should not be empty"); } 
    this.postfix = postfix;
}

private static class TreeNode 
{
    TreeNode left;
    char ch;
    TreeNode right;

    TreeNode(TreeNode left, char ch, TreeNode right) {
        this.left = left;
        this.ch = ch;
        this.right = right;
    }
}

/**
 * Checks to see if it is an Operator
 */
private boolean isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
}


/**
 * Constructs an expression tree, using the postfix expression
 */
public void createExpressionTree() 
{
    final Stack<TreeNode> nodes = new Stack<TreeNode>();
    for (int i = 0; i < postfix.length(); i++) 
    {
        char ch  = postfix.charAt(i);
        if (isOperator(ch))
        {

            TreeNode rightNode = nodes.pop();
            TreeNode leftNode = nodes.pop();
            nodes.push(new TreeNode(leftNode, ch, rightNode));
        }
        else if (!Character.isWhitespace(ch))
        {
            nodes.add(new TreeNode(null, ch, null));
        }
    }
    root = nodes.pop();
}
/**
 * Returns the infix expression
 * 
 * @return  the string of infix.
 */
public String infix() 
{
    if (root == null) 
    {
        throw new NoSuchElementException("The root is empty, the tree has not yet been constructed.");
    }
    final StringBuilder infix = new StringBuilder();
    inOrder(root, infix);
    return infix.toString();
}

private void inOrder(TreeNode node, StringBuilder infix) 
{
    if (node != null) {
        inOrder(node.left, infix);
        infix.append(node.ch);
        inOrder(node.right, infix);
    }
}
public Double evaluate(String postfix)
{
    Stack<Double> s = new Stack<Double>();
    char[] chars = postfix.toCharArray();
    int N = chars.length;
    for(int i = 0; i < N; i++)
    {
        char ch = chars[i];
        if(isOperator(ch))
        {
            switch(ch)
            {
            case '+': s.push(s.pop() + s.pop());     break;
            case '*': s.push(s.pop() * s.pop());     break;
            case '-': s.push(-s.pop() + s.pop());    break;
            case '/': s.push(1 / s.pop() * s.pop()); break;
            }
        }
        else if(Character.isDigit(ch)) 
        {
            s.push(0.0);
            while (Character.isDigit(chars[i]))
                s.push(10.0 * s.pop() + (chars[i++] - '0'));
    }
    } 
        return s.pop();

  }
  }

测试人员：

    import java.util.Scanner;
    public class ExpressionTester
     {
      public static void main(String[] args) 
     {
      Scanner sc = new Scanner(System.in);
       String line = null;
       while(true)
       {
       System.out.println("");
       String pf = sc.nextLine();
        if (pf.isEmpty())
        {
          break;
        }
         ExpressionTree eT = new ExpressionTree(pf);
         eT.createExpressionTree();
         System.out.println("The infix: " + "(" + eT.infix() + ")" );
         System.out.println(eT.evaluate(pf));
       }

      }
      }