Вычислить несколько значений из JTextField с приоритетом оператора

Question

Я написал следующую программу. Моя программа может содержать простые арифметические вычисления, такие как +, -, *, / от значения JTextField. Но мне нужно получить ответ с приоритетом оператора BMDAS (скобки, умножение, разделение, добавление и вычитание) из нескольких значений. пример: типы пользователей 10-5+8/56*(3-5+3): ответ 5. Я упоминаю свой код реализации. как я могу обновить свою программу, чтобы получить вышеуказанное требование? Помоги мне!

import java.awt.event.ActionEvent; 
    import java.awt.event.ActionListener; 
    import javax.swing.JButton; 
    import javax.swing.JFrame; 
    import javax.swing.JTextField; 

public class calculateValue extends JFrame implements ActionListener{ 

    private JButton btn; 
    private JTextField txt; 
    String operator="+-*/()"; 

    public static void main(String args[]){ 
     new calculateValue(); 
    } 

    public calculateValue(){ 
     setSize(300, 200); 
     setLocationRelativeTo(null); 
     setTitle("Calcuate Multiple value!"); 
     setLayout(null); 

     txt=new JTextField(); 
     txt.setBounds(20,20, 150,25); 
     add(txt); 

     btn=new JButton("Show Answer"); 
     btn.setBounds(20, 50,150, 25); 
     btn.addActionListener(this); 
     add(btn); 

     setVisible(true); 
    } 


    public char decideOperator(String s){ 
     char c=' '; 

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

      if(s.contains(operator.charAt(i)+"")){ 
       c=operator.charAt(i); 
      } 
     } 
     return c; 
    } 

    public int decideIndex(String s){ 
     int index=100; 
     for(int i=0;i<operator.length();i++){ 

      if(s.contains(operator.charAt(i)+"")){ 
       index=s.indexOf(operator.charAt(i)); 
      } 
     } 
     return index; 
    } 

    public void actionPerformed(ActionEvent e){ 
     String temp=txt.getText().trim(); 

     double d1=Double.parseDouble(temp.substring(0, decideIndex(temp))); 
     double d2=Double.parseDouble(temp.substring(decideIndex(temp)+1)); 

     if(decideOperator(temp)=='+') System.out.println(d1+d2); 
     else if(decideOperator(temp)=='-') System.out.println(d1-d2); 
     if(decideOperator(temp)=='*') System.out.println(d1*d2); 
     if(decideOperator(temp)=='/') System.out.println(d1/d2); 

    } 
} 

Answer 1

Вам нужно будет использовать либо Reverse Polish Notation для синтаксического анализа и подготовки expresion для расчета (он использует стек для заказа решать математические операции приоритета), или (простое решение) проверить ответ, представленный в следующих SO тема How to parse a mathematical expression given as a string and return a number?

Answer 2

Это может показаться немного чрезмерным, но вот моя реализация выражения распознаватель:

(с учетом как SSCCE):

import java.math.BigDecimal; 

public class Main { 
    public static void main(String[] args) throws Exception{ 
     System.out.println("Final Output: " + evalutateExpression("(56*3)*(4+3)")); 
    } 

    public static double evalutateExpression(String Input){ 
     //This method is extremely sensitive to bad input, try to do some clean up before sending it to the main evaluation body. 
     Input = Input.replaceAll(" ", ""); //Example of a cleanup 

     return Double.parseDouble(recursiveEvalutation(Input)); 
    } 

    private static String recursiveEvalutation(String I){ 
     if(I.contains("(")){ 
      int RIndex = I.indexOf(")"); 
      int LIndex = I.lastIndexOf("(", RIndex); 
      return recursiveEvalutation(I.substring(0, LIndex) + recursiveEvalutation(I.substring(LIndex + 1, RIndex)) + I.substring(RIndex + 1, I.length())); 
     }else if(I.contains("^") || I.contains("√")){ 
      int PowerIndex = I.indexOf("^"); 
      int SQRTIndex = I.indexOf("√"); 

      if(PowerIndex == -1){ 
       PowerIndex = Integer.MAX_VALUE; 
      } 
      if(SQRTIndex == -1){ 
       SQRTIndex = Integer.MAX_VALUE; 
      } 

      if(PowerIndex <= SQRTIndex){ 
       int num2End = findNumberEnd(I.substring(PowerIndex + 1, I.length())) + PowerIndex + 1; 
       int num1Start = findNumberStart(I.substring(0, PowerIndex)); 

       double Num1 = Double.parseDouble(I.substring(num1Start, PowerIndex)); 
       double Num2 = Double.parseDouble(I.substring(PowerIndex + 1, num2End)); 

       String Eval = new BigDecimal(Math.pow(Num1, Num2)).toPlainString(); 

       return recursiveEvalutation(I.substring(0, num1Start) + Eval + I.substring(num2End, I.length())); 
      }else{ 
       int num2End = findNumberEnd(I.substring(SQRTIndex + 1, I.length())) + SQRTIndex + 1; 
       int num1Start = findNumberStart(I.substring(0, SQRTIndex)); 

       double Num1 = Double.parseDouble(I.substring(SQRTIndex + 1, num2End)); 

       String Eval = new BigDecimal(Math.sqrt(Num1)).toPlainString(); 

       return recursiveEvalutation(I.substring(0, num1Start) + Eval + I.substring(num2End, I.length())); 
      } 
     }else if(I.contains("*") || I.contains("/")){ 
      int MultiplyIndex = I.indexOf("*"); 
      int DivideIndex = I.indexOf("/"); 

      if(MultiplyIndex == -1){ 
       MultiplyIndex = Integer.MAX_VALUE; 
      } 
      if(DivideIndex == -1){ 
       DivideIndex = Integer.MAX_VALUE; 
      } 

      if(MultiplyIndex <= DivideIndex){ 
       int num2End = findNumberEnd(I.substring(MultiplyIndex + 1, I.length())) + MultiplyIndex + 1; 
       int num1Start = findNumberStart(I.substring(0, MultiplyIndex)); 
       double Num1 = Double.parseDouble(I.substring(num1Start, MultiplyIndex)); 
       double Num2 = Double.parseDouble(I.substring(MultiplyIndex + 1, num2End)); 

       String Eval = new BigDecimal(Num1 * Num2).toPlainString(); 

       return recursiveEvalutation(I.substring(0, num1Start) + Eval + I.substring(num2End, I.length())); 
      }else{ 
       int num2End = findNumberEnd(I.substring(DivideIndex + 1, I.length())) + DivideIndex + 1; 
       int num1Start = findNumberStart(I.substring(0, DivideIndex)); 
       double Num1 = Double.parseDouble(I.substring(num1Start, DivideIndex)); 
       double Num2 = Double.parseDouble(I.substring(DivideIndex + 1, num2End)); 

       String Eval = new BigDecimal(Num1/Num2).toPlainString(); 

       return recursiveEvalutation(I.substring(0, num1Start) + Eval + I.substring(num2End, I.length())); 
      } 
     }else if(I.contains("+") || I.contains("−")){ 
      int AddIndex = I.indexOf("+"); 
      int MinusIndex = I.indexOf("−"); 

      if(AddIndex == -1){ 
       AddIndex = Integer.MAX_VALUE; 
      } 
      if(MinusIndex == -1){ 
       MinusIndex = Integer.MAX_VALUE; 
      } 

      if(AddIndex <= MinusIndex){ 
       int num2End = findNumberEnd(I.substring(AddIndex + 1, I.length())) + AddIndex + 1; 
       int num1Start = findNumberStart(I.substring(0, AddIndex)); 
       double Num1 = Double.parseDouble(I.substring(num1Start, AddIndex)); 
       double Num2 = Double.parseDouble(I.substring(AddIndex + 1, num2End)); 

       String Eval = new BigDecimal(Num1 + Num2).toPlainString(); 

       return recursiveEvalutation(I.substring(0, num1Start) + Eval + I.substring(num2End, I.length())); 
      }else{ 
       int num2End = findNumberEnd(I.substring(MinusIndex + 1, I.length())) + MinusIndex + 1; 
       int num1Start = findNumberStart(I.substring(0, MinusIndex)); 

       double Num1 = Double.parseDouble(I.substring(num1Start, MinusIndex)); 
       double Num2 = Double.parseDouble(I.substring(MinusIndex + 1, num2End)); 

       String Eval = new BigDecimal(Num1 - Num2).toPlainString(); 

       return recursiveEvalutation(I.substring(0, num1Start) + Eval + I.substring(num2End, I.length())); 
      } 
     }else{ 
      return I; 
     } 
    } 

    private static int findNumberEnd(String I){ 
     char[] expression = I.toCharArray(); 

     for(int x = 0;x < expression.length;x++){ 
      if(!Character.isDigit(expression[x]) && expression[x] != '.' && expression[x] != '-'){ 
       return x; 
      } 
     } 

     return expression.length; 
    } 

    private static int findNumberStart(String I){ 
     char[] expression = I.toCharArray(); 

     for(int x = expression.length - 1;x >= 0;x--){ 
      if(!Character.isDigit(expression[x]) && expression[x] != '.' && expression[x] != '-'){ 
       return x + 1; 
      } 
     } 

     return 0; 
    } 
} 

Выполняет рекурсивную процедуру для непрерывной оценки выражений слева и справа от оператора, следующего за приоритетом оператора. Основным оценщиком является метод рекурсивногоEvalutation().

Ограничения включают:

• Не определено поведение, если выход достигает бесконечности.
• Чрезвычайно интенсивный (создает много много объектов, особенно струнные)

Обратите внимание, что для вычитания, я использую правильный «минус» для операции и дефис для отрицательных чисел.

Изучите код немного, если у вас есть какие-либо вопросы, не стесняйтесь спрашивать.