基于Java的表达式求解算法

guz6ccqo  于 2024-01-05  发布在  Java
关注(0)|答案(3)|浏览(195)

我试图创建一个程序，将在一个表达式作为一个字符串，并解决它。所以，如果输入是3 + 5，它将返回8。我已经做了大部分的编码，但我不知道为什么我一直得到一个UncertedOperationExpression在Java中。请帮助，如果你可以！

**我还必须在这个作业中使用ArrayLists，因为我还没有学习列表。这是我目前为止的代码：

  1. import java.util.Arrays;
  2. import java.util.List;
  3. import java.util.ArrayList;
  5. public class FirstPart {
  6.    public static void main(String[] args) {
  7.       String sampleString = "1 + 2 + 3 / 2 + 1";
  8.       String[] items = sampleString.split(" ");
  9.       List<String> itemList = Arrays.asList(items);
  10.       System.out.println(itemList);
  11.       for(int zz=0; zz<itemList.size(); zz++)
  12.         if(itemList.get(zz).equals("*"))
  13.            {itemList.set(zz-1,Integer.toString((Integer.parseInt(itemList.get(zz-1))*Integer.parseInt(itemList.get(zz+1)))));
  14.            itemList.remove(zz+1);
  15.            itemList.remove(zz);
  16.            zz--;}
  17.         else if(itemList.get(zz).equals("/"))
  18.            {itemList.set(zz-1,Integer.toString((Integer.parseInt(itemList.get(zz-1))/Integer.parseInt(itemList.get(zz+1)))));
  19.            itemList.remove(zz+1);
  20.            itemList.remove(zz);
  21.            zz--;}
  22.       for(int zz=0; zz<itemList.size(); zz++)
  23.         if(itemList.get(zz).equals("+"))
  24.            {itemList.set(zz-1,Integer.toString((Integer.parseInt(itemList.get(zz-1))+Integer.parseInt(itemList.get(zz+1)))));
  25.            itemList.remove(zz+1);
  26.            itemList.remove(zz);
  27.            zz--;}
  28.         else if(itemList.get(zz).equals("-"))
  29.            {itemList.set(zz-1,Integer.toString((Integer.parseInt(itemList.get(zz-1))+Integer.parseInt(itemList.get(zz+1)))));
  30.            itemList.remove(zz+1);
  31.            itemList.remove(zz);
  32.            zz--;}
  33.       System.out.println(itemList);
  34.    }
  35.    }

字符串
再次感谢如果你能帮助！

Java

3条答案

按热度按时间
332nm8kg

332nm8kg1#

如果从这样的数组构造List，

  1. List<String> itemList = Arrays.asList(items)

字符串
返回的列表不允许从列表中删除项目

  1. itemList.remove(zz + 1); // throws java.lang.UnsupportedOperationException

型
相反，创建一个支持删除的空列表，并将所有数组元素添加到其中：

  1. List<String> itemList = new java.util.ArrayList<>();
  2. java.util.Collections.addAll(itemList, items);

型

展开查看全部
赞(0）分享  回复(0）举报  2024-01-05
xjreopfe

xjreopfe2#

尝试阅读关于逆波兰符号算法。它似乎做正是你需要的，你只需要实现它。
https://en.wikipedia.org/wiki/Reverse_Polish_notation

赞(0）分享  回复(0）举报  2024-01-05
qfe3c7zg

qfe3c7zg3#

见我的java程序原件和由Rishi shakya类10日。一个非常强大的表达式求解器可以在BODMAS中轻松执行DMAS。//原件

  1. import java.util.Scanner;
  2. import java.util.ArrayList;
  3. public class Calculator {
  4.     private String arithmeticExpression;
  5.     private ArrayList<Double> numberList = new ArrayList<>();
  6.     private ArrayList<Character> operatorList = new ArrayList<>();
  8.     public Calculator(String ArithmeticExpression) {
  9.         this.arithmeticExpression = '+' + ArithmeticExpression;
  10.     }
  12.     private static String getArithmeticExpression() {
  13.         Scanner in = new Scanner(System.in);
  14.         System.out.println("Enter Your ArithmeticExpression");
  15.         return in.nextLine();
  16.     }
  18.     private double evaluate(double operand1, double operand2, char operator) {
  19.         double result = 0;
  20.         switch (operator) {
  21.             case '+' -> result = operand1 + operand2;
  22.             case '-' -> result = operand1 - operand2;
  23.             case '*' -> result = operand1 * operand2;
  24.             case '/' -> result = operand1 / operand2;
  25.         }
  26.         return result;
  27.     }
  29.     private void getNumbers() {
  30.         String[] Numbers = this.arithmeticExpression.split("[+\\-*/]");
  31.         for (String Number : Numbers) {
  32.             try {
  33.                 numberList.add(Double.parseDouble(Number));
  34.             } catch (NumberFormatException ignored) {
  35.             }
  36.         }
  37.     }
  39.     private void simplifyAdditionSubtractionOperators() {
  40.         StringBuilder simplifiedArithmeticExpression = new StringBuilder();
  41.         String operator = "";
  42.         int lowerBound, upperBound, flowControl = 0, numberCounter = 0;
  43.         char finalOperator, Character;
  44.         for (int counter = 0; counter < this.arithmeticExpression.length(); counter++) {
  45.             Character = this.arithmeticExpression.charAt(counter);
  46.             finalOperator = Character;
  47.             if (Character == '-' || Character == '+') {
  48.                 lowerBound = counter;
  49.                 for (upperBound = lowerBound + 1; upperBound < this.arithmeticExpression.length() &&
  50.                         (this.arithmeticExpression.charAt(upperBound) == '+' || this.arithmeticExpression.charAt(upperBound) == '-'); upperBound++) {
  51.                     if (this.arithmeticExpression.charAt(upperBound - 1) == '+' || this.arithmeticExpression.charAt(upperBound - 1) == '-')
  52.                         if (finalOperator == this.arithmeticExpression.charAt(upperBound))
  53.                             finalOperator = '+';
  54.                         else finalOperator = '-';
  55.                 }
  56.                 counter = upperBound - 1;
  57.             }
  58.             if (Character == '-' || Character == '+' || Character == '*' || Character == '/') {
  59.                 flowControl = 1;
  60.                 operator = String.valueOf(finalOperator);
  61.             }
  62.             if (operator.equals("-"))
  63.                 operator = "+-";
  64.             if (flowControl == 1) {
  65.                 simplifiedArithmeticExpression.append(operator);
  66.                 flowControl = 2;
  67.             } else if (flowControl == 2) {
  68.                 simplifiedArithmeticExpression.append(numberList.get(numberCounter));
  69.                 numberCounter++;
  70.                 flowControl = 0;
  71.             }
  72.         }
  73.         this.arithmeticExpression = simplifiedArithmeticExpression.toString();
  74.     }
  76.     private void simplifyMultiplicationDivisionOperators() {
  77.         char finalOperator, character;
  78.         ArrayList<Character> simplifiedOperatorList = new ArrayList<>();
  79.         for (int counter = 0; counter < this.arithmeticExpression.length(); counter++) {
  80.             character = this.arithmeticExpression.charAt(counter);
  81.             finalOperator = character;
  82.             if (character == '/' || character == '*')
  83.                 if (this.arithmeticExpression.charAt(counter + 1) == '+')
  84.                     counter++;
  85.             if (character == '-' || character == '+' || character == '*' || character == '/')
  86.                 simplifiedOperatorList.add(finalOperator);
  87.         }
  88.         operatorList = simplifiedOperatorList;
  89.     }
  91.     private void evaluateMultiplicationDivision() {
  92.         char operator;
  93.         double result;
  94.         while (operatorList.contains('*') || operatorList.contains('/'))
  95.             for (int i = 1; i < operatorList.size(); i++) {
  96.                 operator = operatorList.get(i);
  97.                 if (operator == '*' || operator == '/') {
  98.                     result = evaluate(numberList.get(i - 1), numberList.get(i), operator);
  99.                     operatorList.remove(i);
  100.                     numberList.remove(i);
  101.                     numberList.add(i, result);
  102.                     numberList.remove(i - 1);
  103.                 }
  104.                 roundAllNumbers(5);
  105.             }
  106.     }
  108.     private void evaluateAdditionSubtraction() {
  109.         double sum = 0;
  110.         roundAllNumbers(5);
  111.         for (double number : numberList)
  112.             sum += number;
  113.         numberList.clear();
  114.         numberList.add(sum);
  115.         roundAllNumbers(5);
  116.     }
  118.     private void getActualNumbers() {
  119.         numberList.clear();
  120.         String[] Numbers = this.arithmeticExpression.split("[+*/]");
  121.         for (String Number : Numbers) {
  122.             try {
  123.                 numberList.add(Double.parseDouble(Number));
  124.             } catch (NumberFormatException ignored) {
  125.             }
  126.         }
  127.     }
  129.     private void updateArithmeticExpression() {
  130.         StringBuilder ArithmeticExpression = new StringBuilder();
  131.         String operator;
  132.         double operand;
  133.         for (int i = 0; i < numberList.size(); i++) {
  134.             operator = Character.toString(operatorList.get(i));
  135.             operand = numberList.get(i);
  136.             ArithmeticExpression.append(operator).append(operand);
  137.         }
  138.         this.arithmeticExpression = ArithmeticExpression.toString();
  139.     }
  141.     private void roundAllNumbers(int n) {
  142.         ArrayList<Double> roundedNumberList = new ArrayList<>();
  143.         double number;
  144.         for (double numberToRound : numberList) {
  145.             number = numberToRound * Math.pow(10, n);
  146.             number = Math.round(number);
  147.             number = number / Math.pow(10, n);
  148.             roundedNumberList.add(number);
  149.         }
  150.         numberList = roundedNumberList;
  151.     }
  153.     private void simplifyArithmeticExpression() {
  154.         getNumbers();
  155.         simplifyAdditionSubtractionOperators();
  156.         simplifyMultiplicationDivisionOperators();
  157.         getActualNumbers();
  158.         operatorList.removeIf(operator -> operator == '-');
  159.         updateArithmeticExpression();
  160.         roundAllNumbers(5);
  161.     }
  163.     public double evaluate() throws SyntaxException,MathException {
  164.         double result ;
  165.         try {
  166.                 simplifyArithmeticExpression();
  167.                 evaluateMultiplicationDivision();
  168.                 evaluateAdditionSubtraction();
  169.                 result = numberList.get(0);
  170.         } catch (IndexOutOfBoundsException e) {
  171.             this.arithmeticExpression = "Syntax Error";
  172.             throw new SyntaxException();
  173.         }
  174.         finally {
  175.                  chackForMathException();
  176.         }
  177.         return result;
  178.     }
  180.     public static void main(String[] args) {
  181.         String ArithmeticExpression;
  182.         double result;
  183.         while (true) {
  184.             ArithmeticExpression = getArithmeticExpression();
  185.             if (ArithmeticExpression.equalsIgnoreCase("EXIT"))
  186.                 break;
  187.             Calculator Calculator = new Calculator(ArithmeticExpression);
  188.                     try {
  189.                         try {
  190.                             result = Calculator.evaluate();
  191.                             System.out.println(" Answer = " + result);
  192.                         }catch (MathException e){
  193.                             System.out.println(e.getMessage());
  194.                         }
  195.                     } catch (SyntaxException e) {
  196.                         System.out.println(e.getMessage());
  197.                     }
  198.         }
  199.     }
  200.     private void chackForMathException() throws MathException{
  201.         double limit = 9.999999999999E12;
  202.         for(double devialValue : numberList)
  203.             if(!(devialValue<=limit)){
  204.                throw new MathException();
  205.             }
  206.     }
  207.     static class MathException extends Throwable{
  208.         public MathException(){}
  209.         @Override
  210.         public String getMessage() {
  211.             return "Math Error : Can't perform operation";
  212.         }
  213.     }
  214.     static class SyntaxException extends Throwable {
  215.         public SyntaxException() {}
  216.         @Override
  217.         public String getMessage() {
  218.            return "Syntax Error !";
  219.         }
  220.     }
  221. }

字符串

展开查看全部
赞(0）分享  回复(0）举报  2024-01-05
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com