Java 如何修复自制解析器中的堆栈溢出？

我正在为类创建一个解析器。用户必须在每个元素之间输入一个空格。然后将每个元素读入其自身索引中的同一数组中。我的堆栈不断溢出。我想这是因为只有最后一次调用MyCalculation函数才会真正结束。但是，如果是这种情况，我不确定如何组织代码来避免这种情况。提前感谢您的帮助

import java.util.Scanner;

public class InterpreterFour{
    public static void main(String []args){
    //read in the values as a string
    Scanner scan = new Scanner(System.in);
    String expressions = scan.nextLine();
    //save each token into the array
    String[] token = expressions.split("\\s+");

    int solved = 0;
    int o = 0;
    //call myCalculus function which will call the other functions
    System.out.println(myCalculus(token, 0, solved));
    }

    public static int myCalculus(String[] token, int o, int solved){
        while(o < token.length-1){
            if(token[o].equals("*")){
                multiply(token, o, solved);
            }
            else if(token[o].equals("+")){
                add(token, o, solved);
            }
            else if(token[o].equals("<")){
                compare(token, o, solved);
            }
            else if(token[o].equals("<=")){
                compare(token, o, solved);
            }
            else if(token[o].equals(">")){
                compare(token, o, solved);
            }
            else if(token[o].equals("<=")){
                compare(token, o, solved);
            }
            else if(token[o].equals("(")){
                myCalculus(token, o++, solved);
            }
            else{
                myCalculus(token, o++, solved);
            }
        }
        return solved;
    }

    public static void add(String[] token, int o, int solved){
        if(token[o++].matches("[-+]?\\d*\\.?\\d+")){
            solved = solved + Integer.parseInt(token[o--]) + Integer.parseInt(token[o++]);
            myCalculus(token, o++, solved);
        }
        else{
            myCalculus(token, o++, solved);
        }
    }

    public static void multiply(String[] token, int o, int solved){
        if(token[o++].matches("[-+]?\\d*\\.?\\d+")){
            solved = solved + Integer.parseInt(token[o--]) * Integer.parseInt(token[o++]);
            myCalculus(token, o++, solved);
        }
        else{
            myCalculus(token, o++, solved);
        }
    }

    public static void compare(String[] token, int o, int solved){
        if(token[o++].matches("[-+]?\\d*\\.?\\d+")){
            if(token[o].equals("<")){
                solved = solved + ((Integer.parseInt(token[o--]) < Integer.parseInt(token[o++])) ? 1 : 0);
            }
            else if(token[o].equals(">")){
                solved = solved + ((Integer.parseInt(token[o--]) > Integer.parseInt(token[o++])) ? 1 : 0);
            }
            else if(token[o].equals("<=")){
                solved = solved + ((Integer.parseInt(token[o--]) <= Integer.parseInt(token[o++])) ? 1 : 0);
            }
            else{
                solved = solved + ((Integer.parseInt(token[o--]) >= Integer.parseInt(token[o++])) ? 1 : 0);
            }
            myCalculus(token, o++, solved);
        }
        else{
            myCalculus(token, o++, solved);
        }
    }
}

import java.util.Scanner；
公共班口译员{
公共静态void main（字符串[]args）{
//以字符串形式读入值
扫描仪扫描=新扫描仪（System.in）；
字符串表达式=scan.nextLine（）；
//将每个令牌保存到数组中
字符串[]标记=表达式。拆分（\\s+）；
int=0；
INTO=0；
//调用MyCalculation函数，该函数将调用其他函数
System.out.println（mycalculation（token，0，solved））；
}
公共静态int-mycalculation（字符串[]标记，int-o，int-solved）{
while（oelse if（token[o].equals（“我认为您需要将递归调用更改为使用
++o
，而不是
o++
：

myCalculus(token, ++o, solved);

当前代码在调用
mycalculation
后只会递增
o
，因此每当遇到括号时，代码将进入无限循环。
Java中的参数是通过值传递的，而不是通过引用传递的

您的任何方法都不会返回值。您似乎希望
solved
将包含最终值，但它不会，因为它是按值传递的

出于同样的原因，实际上不需要所有的
++
运算符。您只需将o+1传递给较低级别。这不会影响递归较高级别中的“o”变量

最后，您的
mycalculation
方法中的while循环没有意义，因为您在其他方法中进行递归。因此while只会导致计算出错

还要注意的是，你对括号的处理可能是错误的。你没有在任何地方处理右括号，这也可能会导致错误的计算。
这确实解决了问题。但是，现在，没有返回任何解决方案。我认为你应该将新解分为一个新问题。答案对任何人来说都没有意义ho需要稍后阅读。关于StackOverflow的问题应该是其他有类似问题的人的公共资源。好的，我有。谢谢你的建议。