Question

我试图在Java中创建一个简单的计算器，它以字符串的形式输入并执行一个简单的＆＃39; +＆＃39;和＆＃39; - ＆＃39;操作

单个数字输入有效但我的问题是当我尝试将其用于双位数时

输入字符串为：5 + 20 + 5 + 11
列表1 = [5,20,2,0,5,11,1]
list 2 = [+，+，+]
回答：27

我需要找到一种方法，在list1中存储[5]后如何添加[5,20]而不是当前代码正在执行的[5,20,2,0]。

public int calC(String input) {
        int len = input.length();
        ArrayList list1 = new ArrayList();
        ArrayList list2 = new ArrayList();
        for (int i = 0; i < len; i++) {
            if ((input.charAt(i) != '+') && (input.charAt(i) != '-')) {
                // check if the number is double-digit
                if ((i + 1 <= len - 1)) {
                    if ((input.charAt(i + 1) != '+')&& (input.charAt(i + 1) != '-')) {
                        String temp = "";
                        temp = temp + input.charAt(i) + input.charAt(i + 1);
                        int tempToInt = Integer.parseInt(temp);
                        // adding the double digit number
                        list1.add(tempToInt);
                    }
                    // add single digit number
                    list1.add(input.charAt(i) - '0');
                }
            } else {
                // adding the symbols
                list2.add(input.charAt(i));
            }
        }
        int result = 0;
        result = result + (int) list1.get(0);
        for (int t = 0; t < list2.size(); t++) {
            char oper = (char) list2.get(t);
            if (oper == '+') {
                result = result + (int) list1.get(t + 1);

            } else if (oper == '-') {
                result = result - (int) list1.get(t + 1);
            }
        }
        return result;
    }

编辑：工作版本
@Ker p pag感谢更新的方法
输入字符串为：5 + 20 + 5 + 11
[5,20,5,11]
[+，+，+]
答：41
我需要尝试使用堆栈按照建议实现此功能，但当前版本可以正常工作

static boolean isDigit(char check) {
    if (Character.isDigit(check)) {
        return true;
    }
    return false;
}
public static int calC(String input) {

    int len = input.length();
    ArrayList list1 = new ArrayList();
    ArrayList list2 = new ArrayList();

    for (int i = 0; i < len; i++) {
        if ((i + 1 <= len - 1)) {
            if (isDigit(input.charAt(i)) && isDigit(input.charAt(i + 1))) {
                String temp = input.charAt(i) + "" + input.charAt(i + 1);
                int toInt = Integer.parseInt(temp);
                list1.add(toInt);
                i = i+1;
            } else if (isDigit(input.charAt(i))) {
                list1.add(input.charAt(i)- '0');
            } else {
                list2.add(input.charAt(i));
            }

        }
    }

    int result = 0;
    result = result + (int) list1.get(0);
    for (int t = 0; t < list2.size(); t++) {
        char oper = (char) list2.get(t);
        if (oper == '+') {
            result = result + (int) list1.get(t + 1);

        } else if (oper == '-') {
            result = result - (int) list1.get(t + 1);
        }
    }
    return result;
}

Answer 1

如果您希望结果41用于输入字符串"5+20+5+11"，为什么不将ScriptEngineManager与JavaScript引擎一起使用，

public double calC(String input) {
    int result = 0;
    ScriptEngineManager mgr = new ScriptEngineManager();    
    ScriptEngine engine = mgr.getEngineByName("JavaScript");        
    return (Double)engine.eval(input);
}

但请注意，此处的返回类型为double。

如果在这种情况下只想要int作为返回类型，请尝试使用此

return new BigDecimal(engine.eval(input).toString()).intValue();

Answer 2

以下是代码：

    String a = "5+20-15+8";
    System.out.println(a);
    String operators[]=a.split("[0-9]+");
    String operands[]=a.split("[+-]");
    int agregate = Integer.parseInt(operands[0]);
    for(int i=1;i<operands.length;i++){
        if(operators[i].equals("+"))
            agregate += Integer.parseInt(operands[i]);
        else 
            agregate -= Integer.parseInt(operands[i]);
    }
    System.out.println(agregate);

Answer 3

另一种思考方式：

public class InlineParsing {
    public static void main(String []args){
        String input = "5-2+20+5+11-10";
        input = input.replace(" ","");

        String parsedInteger = "";
        String operator = "";
        int aggregate = 0;
        for (int i = 0; i < input.length(); i++){
            char c = input.charAt(i); 
            if (Character.isDigit(c)) {
                parsedInteger += c;
            }
            if (!Character.isDigit(c) || i == input.length()-1){
                int parsed = Integer.parseInt(parsedInteger);
                if (operator == "") {
                    aggregate = parsed;
                }
                else {
                    if (operator.equals("+")) {
                        aggregate += parsed;
                    }else if (operator.equals("-")){
                        aggregate -= parsed;
                    }
                }

                parsedInteger ="";
                operator = ""+c;
            }
        }
        System.out.println("Sum of " + input+":\r\n" + aggregate);
    }
}

它基本上是遍历每个字符的状态机。

迭代每个字符：

如果当前字符是数字，则添加到当前数字缓冲区
如果当前字符不是数字或我们正在解析最后一位数字
1. 如果已解析运算符，则使用该值将新解析的数字添加到总和中如果没有解析运算符，则将sum设置为当前已解析的数字
2. 清除当前号码缓冲区
3. 将当前字符存储为运算符

Answer 4

用于将输入存储到列表中，您可以尝试使用此代码段

for (int i = 0; i < input.length() - 1; i++) {

        // make a method
        // check if current character is number || check if current
        // character is number and the next character
        if (isDigit(input.charAt(i)) && isDigit(input.charAt(i + 1))) {

            list.add(input.charAt(i) +""+ input.charAt(i + 1));

        } else if (isDigit(input.charAt(i))) {

            list.add(input.charAt(i));

        }else{
            operator.add(input.charAt(i));
        }

    }


//check if it is a number
public boolean isDigit(char input){
if(input == '1' ||
input == '2' ||
input == '3' ||
input == '4' ||
input == '5' ||
input == '6' ||
input == '7' ||
input == '8' ||
input == '9' ||
input == '0')
    return true;

    return false;
}

Answer 5

我同意堆栈是最好的解决方案，但仍然提供另一种方法这样做。

   String input = "5+20+11+1";
   StringBuilder sb = new StringBuilder();
   List<Integer> list1 = new ArrayList<Integer>();
   List<Character> list2 = new ArrayList<Character>();
   char[] ch = input.toCharArray();
   for(int i=0;i<ch.length;i++)
   {
       if(ch[i]!='+')
       { 

           sb.append(ch[i]);
       }else
       {

           list2.add(ch[i]);
           list1.add(Integer.valueOf(sb.toString()));
           sb.setLength(0); 
       }
   }
   if(sb.length()!=0)
       list1.add(Integer.valueOf(sb.toString()));
   System.out.println(list1.size());
   for(Integer i:list1)
   {
       System.out.println("values"+i);
   }

Answer 6

我可以建议你使用Exp4j。从以下示例代码中可以看出，这很容易理解：

Expression e = new ExpressionBuilder("3 * sin(y) - 2 / (x - 2)")
    .variables("x", "y")
    .build()
    .setVariable("x", 2.3)
    .setVariable("y", 3.14);
double result = e.evaluate();

特别是对于使用更复杂表达式的情况，这可能是更好的选择。

Answer 7

private static int myCal() {
 String[] digits = {
  "1",
  "2",
  "3",
  "4",
  "5"
 };
 String[] ops = {
  "+",
  "+",
  "+",
  "-"
 };
 int temp = 0;
 int res = 0;
 int count = ops.length;

 for (int i = 0; i < digits.length; i++) {

  res = Integer.parseInt(digits[i]);
  if (i != 0 && count != 0) {
   count--;
   switch (ops[i - 1]) {
    case "+":
     temp = Math.addExact(temp, res);
     break;

    case "-":
     temp = Math.subtractExact(temp, res);
     break;
    case "*":
     temp = Math.multiplyExact(temp, res);
     break;
    case "/":
     temp = Math.floorDiv(temp, res);
     break;
   }
  }
 }
 return temp;
}

Answer 8

您可以查看我仅使用数组创建的这段代码。我还尝试了几个算术题，也是你给出的问题。

另请参阅方法中的注释。

public static String Calculator(String str) {
    // will get all numbers and store it to `numberStr`
    String numberStr[] = str.replaceAll("[+*/()-]+"," ").split(" ");
    // will get all operators and store it to `operatorStr`
    String operatorStr[] = str.replaceAll("[0-9()]+","").split("");

    int total = Integer.parseInt(numberStr[0]);

    for (int i=0; i<operatorStr.length; i++) {
        switch (operatorStr[i]) {
            case "+" :
                total += Integer.parseInt(numberStr[i+1]);
                break;
            case "-" :
                total -= Integer.parseInt(numberStr[i+1]);
                break;
            case "*" :
                total *= Integer.parseInt(numberStr[i+1]);
                break;
            case "/" :
                total /= Integer.parseInt(numberStr[i+1]);
                break;
        }

        if(i+2 >= operatorStr.length) continue; // if meets the last operands already
        numberStr[i+1] = String.valueOf(total);

    }
    return String.valueOf(total);
}

Java字符串计算器

8 个答案: