Java 从字符串到整数函数

我正在尝试编写一个程序，将函数作为字符串接收并求解它。例如，“5*5+2/2-8+5*5-2”应返回41

我编写了乘法和除法的代码，它工作得非常完美：

  public class Solver 
{
    public static void operationS(String m) 
    {
        ArrayList<String> z = new ArrayList<String>();
        char e= ' ';
        String x= " ";
        for (int i =0; i<m.length();i++)
        {
            e= m.charAt(i);
            x= Character.toString(e);


            z.add(x);
        }
         for (int i =0; i<z.size();i++)
            {
                System.out.print(z.get(i));
            }

        other(z);
    }

    public static void other(ArrayList<String> j)
    {
        int n1=0;
        int n2=0;
        int f=0;
        String n= " ";
          for (int m=0; m<j.size();m++)
          {

              if ((j.get(m)).equals("*"))
              {
                 n1 = Integer.parseInt(j.get(m-1));
                 n2 = Integer.parseInt(j.get(m+1));
                 f= n1*n2;
                 n = Integer.toString(f);

                 j.set(m,n);
                 j.remove(m+1);
                 j.remove(m-1);

                 m=0;
              }

              for (int e=0; e<j.size();e++)
              {

                  if ((j.get(e)).equals("/"))
                  {
                     n1 = Integer.parseInt(j.get(e-1));
                     n2 = Integer.parseInt(j.get(e+1));
                     f= n1/n2;
                     n = Integer.toString(f);

                     j.set(e,n);
                     j.remove(e+1);
                     j.remove(e-1);

                     e=0;
                  }

              }   
    }

          System.out.println();
          for (int i1 =0; i1<j.size();i1++)
            {
                System.out.print(j.get(i1)+",");
            }

公共类求解器
{
公共静态无效操作（字符串m）
{
ArrayList z=新的ArrayList（）；
字符e=''；
字符串x=“”；
对于（inti=0；i来说，寻求一个对你的具体问题没有帮助的答案，但希望它能帮助你更进一步

乍一看，您的代码存在各种问题：

你到处都在使用超短的变量名。这可能会为你节省1分钟的键入时间；每次阅读代码都会花费你5、10、x分钟的时间；或者将代码展示给其他人。因此：不要这样做。使用能说明名称背后的含义的名称
您正在使用大量低级代码。例如，您使用“couting for”循环来迭代列表（称为j，这真是太可怕了！）。这意味着：您使代码的阅读变得比应该的复杂得多
这样看来，似乎到目前为止还没有人告诉你，但代码的理念是：它应该易于阅读和理解。也许你不会因此得到分数，但请相信我：从长远来看，学习编写可读代码是一项非常重要的技能。如果这让你好奇，看看你是否能获得“干净代码”的帮助罗伯特·马丁著。研究那本书。然后再研究一遍。再研究一遍
但真正的问题是你解决这个问题的方法。我假设：这是学习作业的一部分。下一步你不会有简单的表达，比如“1+2*3”；而是要求你处理类似“sqrt（2）+3”的事情等等。然后你会被要求添加变量，等等。然后你的整个方法会被打破。因为你的简单字符串操作将不再这样做

从这个意义上说：您应该仔细研究这一点，并仔细研究Boann的第二个答案，以了解如何创建一个解析器，该解析器将您的输入字符串分解为表达式，然后进行计算。您的代码“同时”完成这两项工作；因此很难增强提供的功能。
您有两个问题：

1） 
g=0；
if和else块后面的语句将使您进入无限循环

2） 根据您给出的输出，第一个减号（-）是Unicode字符
连字符减号（U+002D）
，而第二个减号（–）是Unicode字符
EN破折号（U+2013）
，因此
（j.get（g））。等号（“-”）
第二个减号失败，因为它们不相等。
您可以使用内置的Javascript引擎

public static void main(String[] args) throws Exception{
    ScriptEngineManager mgr = new ScriptEngineManager();
    ScriptEngine engine = mgr.getEngineByName("JavaScript");
    String code = "5*5+2/2-8+5*5-2";
    System.out.println(engine.eval(code));
}

基本上不要重复你自己（枯燥的原则）。并且使用抽象（全名，合理时使用提取方法）。当使用多个方法时，静态方法有点麻烦。在这里，使用单独的方法很方便

也许你想要这样的东西：

Solver solver = new Solver();
List<String> expr = solver.expression("5*5+2/2-8+5*5-2");
String result = solver.solve(expr);

上述内容可以在几个方面进行改进。但它可读性强，可重写。
公共类求解器{
public class Solver {
public static void main(String args[]) {
    operation("5+2*5-6/2+1+5*12/3");
}

public static void operation(String m) {
    ArrayList<Object> expressions = new ArrayList<Object>();
    String e;
    String x = "";
    for (int i = 0; i < m.length(); i++) {
        e = m.substring(i, i + 1);
        if (!(e.equals("*") || e.equals("/") || e.equals("+") || e
                .equals("-"))) {
            x += e;
            continue;
        } else {
            if (!x.equals("") && x.matches("[0-9]+")) {
                int oper = Integer.parseInt(x);
                expressions.add(oper);
                expressions.add(m.charAt(i));
                x = "";
            }
        }
    }
    if (!x.equals("") && x.matches("[0-9]+")) {
        int oper = Integer.parseInt(x);
        expressions.add(oper);
        x = "";
    }
    for (int i = 0; i < expressions.size(); i++) {
        System.out.println(expressions.get(i));
    }
    evaluateExpression(expressions);
}

public static void evaluateExpression(ArrayList<Object> exp) {
    //Considering priorities we calculate * and / first and put them in a list mulDivList
    ArrayList<Object> mulDivList=new ArrayList<Object>();
    for (int i = 0; i < exp.size(); i++) {
        if (exp.get(i) instanceof Character) {
            if ((exp.get(i)).equals('*')) {
                int tempRes = (int) exp.get(i - 1) * (int) exp.get(i + 1);
                exp.set(i - 1, null);
                exp.set(i, null);
                exp.set(i + 1, tempRes);
            }
            else if ((exp.get(i)).equals('/')) {
                int tempRes = (int) exp.get(i - 1) / (int) exp.get(i + 1);
                exp.set(i - 1, null);
                exp.set(i, null);
                exp.set(i + 1, tempRes);
            }
        }
    }
    //Create new list with only + and - operations

    for(int i=0;i<exp.size();i++)
    {
        if(exp.get(i)!=null)
            mulDivList.add(exp.get(i));
    }
    //Calculate + and - .
    for(int i=0;i<mulDivList.size();i++)
    {
         if ((mulDivList.get(i)).equals('+')) {
            int tempRes = (int) mulDivList.get(i - 1) + (int) mulDivList.get(i + 1);
            mulDivList.set(i - 1, null);
            mulDivList.set(i, null);
            mulDivList.set(i + 1, tempRes);
        }
        else if ((mulDivList.get(i)).equals('-')) {
            int tempRes = (int) mulDivList.get(i - 1) - (int) mulDivList.get(i + 1);
            mulDivList.set(i - 1, null);
            mulDivList.set(i, null);
            mulDivList.set(i + 1, tempRes);
        }
    }
    System.out.println("Result is : " + mulDivList.get(mulDivList.size() - 1));

}
}

公共静态void main（字符串参数[]）{
操作（“5+2*5-6/2+1+5*12/3”）；
}
公共静态无效操作（字符串m）{
ArrayList表达式=新的ArrayList（）；
字符串e；
字符串x=“”；
对于（int i=0；ifor（int i=0；i并且您在
for
循环中设置了
g=0
，我认为这将是一个无限循环。@我想您是想“移动”您的评论到问题上。我认为您在这里“与”错误的人交谈；-）因为我想让它从一开始就检查@Whatzs@ZeldaX不，问题是你写的代码你不明白它在做什么。这是这里最重要的事情。这是很好的事情。总是有人识别“立即”问题也是。我似乎不明白数字2。如何在我的代码中解决这个问题？对不起，谢谢。这不是关于代码，而是关于输入。第二个减号不是减号，是破折号，它是一个不同的字符。哦，好的，谢谢！但是为什么“+”也不起作用呢？@uoyilmazI尝试了，输出是“43，–，2，”在你移除额外的g=0之后，在if块之外。所以“+”起作用。它的可能重复是为了一个赋值，我需要把它写成l
class Solver {

    List<String> expression(String expr) {
        String[] args = expr.split("\\b");
        List<String> result = new ArrayList<>();
        Collections.addAll(result, args);
        return result;
    }

    String solve(List<String> args) {
        solveBinaryOps(args, "[*/]");
        solveBinaryOps(args, "[-+]");
        return args.stream().collect(Collectors.joining(""));
    }

    private void solveBinaryOps(List<String> args, String opPattern) {
        for (int i = 1; i + 1 < args.length; ++i) {
            if (args.get(i).matches(opPattern)) {
                String value = evalBinaryOp(args.get(i - 1), args.get(i), args.get(i + 1));
                args.set(i, value);
                args.remove(i + 1);
                args.remove(i - 1);
                --i; // Continue from here.
            }
        }
    }

    private String evalBinaryOp(String lhs, String op, String rhs) {
        int x = Integer.parseInt(lhs);
        int y = Integer.parseInt(rhs);
        int z = 0;
        switch (op) {
        case "*":
            z = x * y;
            break;
        case "/":
            z = x / y;
            break;
        case "+":
            z = x + y;
            break;
        case "-":
            z = x - y;
            break;
        }
        return Integer.toString(z);
     }
}

public class Solver {
public static void main(String args[]) {
    operation("5+2*5-6/2+1+5*12/3");
}

public static void operation(String m) {
    ArrayList<Object> expressions = new ArrayList<Object>();
    String e;
    String x = "";
    for (int i = 0; i < m.length(); i++) {
        e = m.substring(i, i + 1);
        if (!(e.equals("*") || e.equals("/") || e.equals("+") || e
                .equals("-"))) {
            x += e;
            continue;
        } else {
            if (!x.equals("") && x.matches("[0-9]+")) {
                int oper = Integer.parseInt(x);
                expressions.add(oper);
                expressions.add(m.charAt(i));
                x = "";
            }
        }
    }
    if (!x.equals("") && x.matches("[0-9]+")) {
        int oper = Integer.parseInt(x);
        expressions.add(oper);
        x = "";
    }
    for (int i = 0; i < expressions.size(); i++) {
        System.out.println(expressions.get(i));
    }
    evaluateExpression(expressions);
}

public static void evaluateExpression(ArrayList<Object> exp) {
    //Considering priorities we calculate * and / first and put them in a list mulDivList
    ArrayList<Object> mulDivList=new ArrayList<Object>();
    for (int i = 0; i < exp.size(); i++) {
        if (exp.get(i) instanceof Character) {
            if ((exp.get(i)).equals('*')) {
                int tempRes = (int) exp.get(i - 1) * (int) exp.get(i + 1);
                exp.set(i - 1, null);
                exp.set(i, null);
                exp.set(i + 1, tempRes);
            }
            else if ((exp.get(i)).equals('/')) {
                int tempRes = (int) exp.get(i - 1) / (int) exp.get(i + 1);
                exp.set(i - 1, null);
                exp.set(i, null);
                exp.set(i + 1, tempRes);
            }
        }
    }
    //Create new list with only + and - operations

    for(int i=0;i<exp.size();i++)
    {
        if(exp.get(i)!=null)
            mulDivList.add(exp.get(i));
    }
    //Calculate + and - .
    for(int i=0;i<mulDivList.size();i++)
    {
         if ((mulDivList.get(i)).equals('+')) {
            int tempRes = (int) mulDivList.get(i - 1) + (int) mulDivList.get(i + 1);
            mulDivList.set(i - 1, null);
            mulDivList.set(i, null);
            mulDivList.set(i + 1, tempRes);
        }
        else if ((mulDivList.get(i)).equals('-')) {
            int tempRes = (int) mulDivList.get(i - 1) - (int) mulDivList.get(i + 1);
            mulDivList.set(i - 1, null);
            mulDivList.set(i, null);
            mulDivList.set(i + 1, tempRes);
        }
    }
    System.out.println("Result is : " + mulDivList.get(mulDivList.size() - 1));

}
}