Java 简单到复杂方程的弦方程

我正试图编写一个程序，通过使用Arraylist将方程分解为单独的部分，以字符串的形式求解任何方程（从简单到复杂）。它首先检查括号，然后进入它能找到的最深的括号集，并从更强的运算符开始求解其中的操作集，然后继续。它继续检查，直到没有更多的括号，然后执行剩下的操作，从更强的运算符开始。arraylist中剩余的数字就是答案。但我有麻烦了。这是我的密码：

import java.util.ArrayList;

public class StringEquation
{
    public static void main(String[] args) 
    {
        String s = "80+5+3*(11%(3*2)-(5+1)+6)-(10+10)+(2*2)*5";

        ArrayList<String> equation = new ArrayList<>();

        String ns = "";

        String b;

        int nsi;

        int si;

        int res = 0;

        boolean hasParen = false;

        for(int c=0; c<s.length(); c++)
        {
             b = s.substring(c,c+1);
             if("0".equals(b)||"1".equals(b)||"2".equals(b)||"3".equals(b)||"4".equals(b)||"5".equals(b)||"6".equals(b)||"7".equals(b)||"8".equals(b)||"9".equals(b))
             {
                 ns += b;
                 if(c==s.length()-1)
                 {
                     nsi = Integer.parseInt(ns);
                     equation.add(Integer.toString(nsi));
                 }
             }
             else if(("+".equals(b)||"-".equals(b)||"*".equals(b)||"/".equals(b)||"%".equals(b))&&!"".equals(ns))
             {
                nsi = Integer.parseInt(ns);
                equation.add(Integer.toString(nsi));
                equation.add(b);
                ns = "";
             }
             else if("(".equals(b))
             {
                 equation.add(b);
             }
             else if (")".equals(b))
             {
                nsi = Integer.parseInt(ns);
                equation.add(Integer.toString(nsi));
                equation.add(b);
                ns = "";
             }
             else if("+".equals(b)||"-".equals(b)||"*".equals(b)||"/".equals(b)||"%".equals(b))
             {
                 equation.add(b);
             }
        }

        while(true) //checks for parentheses
        {
            for(int d=0; d<equation.size(); d++)
            {
                if("(".equals(equation.get(d)))
                {
                    hasParen = true;
                }

                if(hasParen==true)
                {
                    while(!")".equals(equation.get(d)))
                    {
                        d++;
                    }
                    while(!"(".equals(equation.get(d)))
                    {
                        d--;
                    }
                    d++;

                    while(!")".equals(equation.get(d+1)))
                    {
                        if("-".equals(equation.get(d))) //checks to see if the String number on the Arraylist is negative
                        {
                            equation.remove(d);
                            si = Integer.parseInt(equation.get(d));
                            si *= -1;
                        }
                        else
                        {
                            si = Integer.parseInt(equation.get(d));
                        }

                        switch(equation.get(d+1))
                        {
                            case "*": si *= Integer.parseInt(equation.get(d+2)); 
                            equation.set(d, Integer.toString(si));
                            equation.remove(d+1);
                            equation.remove(d+2);
                                break;
                            case "/": si /= Integer.parseInt(equation.get(d+2));
                            equation.set(d, Integer.toString(si));
                            equation.remove(d+1);
                            equation.remove(d+2);
                                break;
                            case "%": si %= Integer.parseInt(equation.get(d+2));
                            equation.set(d, Integer.toString(si));
                            equation.remove(d+1);
                            equation.remove(d+2);
                                break;
                            default: d+=2;
                        }
                    }

                    while(!"(".equals(equation.get(d)))
                    {
                        d--;
                    }
                    d++;

                    while(!")".equals(equation.get(d+1)))
                    {
                        if("-".equals(equation.get(d))) //checks to see if the String number on the Arraylist is negative
                        {
                            equation.remove(d);
                            si = Integer.parseInt(equation.get(d));
                            si *= -1;
                        }
                        else
                        {
                            si = Integer.parseInt(equation.get(d));
                        }

                        switch(equation.get(d+1))
                        {
                            case "+": si += Integer.parseInt(equation.get(d+2)); 
                            equation.set(d, Integer.toString(si));
                            equation.remove(d+1);
                            equation.remove(d+2);
                                break;
                            case "-": si -= Integer.parseInt(equation.get(d+2));
                            equation.set(d, Integer.toString(si));
                            equation.remove(d+1);
                            equation.remove(d+2);
                                break;
                        }
                    }

                    if("(".equals(equation.get(d-1))&&")".equals(equation.get(d+1)))
                    {
                        equation.remove(d-1);
                        equation.remove(d+1);
                    }

                    hasParen = false;

                    d = 0;
                }
            }
            break;
        }

        for(int e=0; e<equation.size(); e+=2) //does all multiplication, division and modulus first
        {
            if("-".equals(equation.get(e))) //checks to see if the String number on the Arraylist is negative
            {
                equation.remove(e);
                si = Integer.parseInt(equation.get(e));
                si *= -1;
            }
            else
            {
                si = Integer.parseInt(equation.get(e));
            }

            switch(equation.get(e+1))
            {
                case "*": si *= Integer.parseInt(equation.get(e+2)); 
                equation.set(e, Integer.toString(si));
                equation.remove(e+1);
                equation.remove(e+2);
                    break;
                case "/": si /= Integer.parseInt(equation.get(e+2));
                equation.set(e, Integer.toString(si));
                equation.remove(e+1);
                equation.remove(e+2);
                    break;
                case "%": si %= Integer.parseInt(equation.get(e+2));
                equation.set(e, Integer.toString(si));
                equation.remove(e+1);
                equation.remove(e+2);
                    break;
                default: e+=2;
            }
        }

        for(int f=0; f<equation.size(); f+=2) //does the rest (addition and subtraction)
        {
            if("-".equals(equation.get(f))) //checks to see if the String number on the Arraylist is negative
            {
                equation.remove(f);
                si = Integer.parseInt(equation.get(f));
                si *= -1;
            }
            else
            {
                si = Integer.parseInt(equation.get(f));
            }

            switch(equation.get(f+1))
            {
                case "+": si += Integer.parseInt(equation.get(f+2)); 
                equation.set(f, Integer.toString(si));
                equation.remove(f+1);
                equation.remove(f+2);
                    break;
                case "-": si -= Integer.parseInt(equation.get(f+2));
                equation.set(f, Integer.toString(si));
                equation.remove(f+1);
                equation.remove(f+2);
                    break;
            }
        }

        System.out.print(equation.get(0)); //Arraylist should only have the answer of the string equation by this point.

        //The part below was to see if lines 25-59 had obtained the whole equation in seperate parts within the arraylist.

//        for(int i=0; i<equation.size(); i++)
//        {
//            System.out.print(equation.get(i));
//        }
//        System.out.println("\n");
    }
}

有什么帮助吗？

请参阅以下文档：

抛出：NumberFormatException-如果字符串不包含 可分解整数

您收到的错误消息信息非常丰富

您正在尝试解析

”（“

”，它不是一个可解析的整数

---

使用调试器将在不到一分钟的时间内为您解决此问题。

您确实应该为此使用解析/词法分析框架，然后在解析树的顶部实现方程解算器

---

这里有一个起点：

如前所述，您正试图将“（”作为一个整数进行解析

但这不是你的主要问题

主要的问题是你有大量的代码，这是不必要的难以解释的

您需要将字符串转换为树状结构，而不是数组列表，这将使您能够以更简单、无错误的方式进行计算

由于您的问题很简单，我不建议使用解析器生成器来完成此任务。（imho花费的时间太长）。但是，您仍然需要设计数据结构以满足您的需求

有很多数学方程的解析器，你可以从中得到启发

通常情况下，您会遇到以下情况：

Class Statement{}

class AddStatement extends Statement{
    Statement lhs;
    Statement rhs;
}

Class constant extends Statement{
    int value;
}

您需要为您支持的所有操作创建类，然后递归地将输入解析到此结构中。如果操作正确，计算将变得简单

我不打算详细说明，因为网上有足够的资源可用于指导

---

如果您希望继续上面的代码，但我建议您以某种方式找出如何将其分割成更小的块，这样更易于调试，祝您好运

p.S这在haskell之类的函数式语言中要容易得多

Class Statement{}

class AddStatement extends Statement{
    Statement lhs;
    Statement rhs;
}

Class constant extends Statement{
    int value;
}