Из инфикс в постфикс

import java.util.*;
 
public class Evaluator {
    private String expression;
    private String rpn;
    
    public Evaluator(String expression) {
        this.expression = expression;
    }
    
    public String Convert(){
        Stack <String> myStack = new Stack<String>();
        Queue<String> myQueue = new LinkedList<String>();
        
        String operands = "0123456789";
        String operators = "+-/*%^";
        
        String leftBracket = "(";
        String rightBracket = ")";
        
        
        for (int i=0; i<this.expression.length(); i++){
            String c = Character.toString(this.expression.charAt(i));
            if (operands.contains(c)){
                myQueue.add(c);
                System.out.println(myQueue);
            }
            else if (operators.contains(c)) {
                while(!myStack.isEmpty() && (precedence(myStack.peek()) > precedence(c))){
                    myQueue.add(myStack.pop());
                    
                }
                myStack.push(c);
                
                                
            }
            else if (leftBracket.contains(c)){
                myStack.push(c);
            }
            else if (rightBracket.contains(c)){
                if (myStack.peek().toString() != "("){
                    myQueue.add(myStack.pop());
                }
                else{
                    myStack.pop();
                }
            }           
        }
        
        while (!myStack.isEmpty()){
            if (!myStack.peek().equals(leftBracket)){
                myQueue.add(myStack.pop());
                System.out.println("123");
            }
            else{
                myStack.pop();
                System.out.println("456");
            }
        }
        
        return this.rpn = myQueue.toString();
    }
    public double Compute(){
        String operands = "0123456789";
        String operators = "+-/*%^";
        Stack <String> myStack = new Stack<String>();
        double result = 0;
            
        for (int i=0; i<this.rpn.length(); i++){
            String c = Character.toString(this.rpn.charAt(i));
                        
            if (operands.contains(c)){
                myStack.push(c);
            }
            else if (operators.contains(c)){
                double operand1 = Double.parseDouble(myStack.pop());
                double operand2 = Double.parseDouble(myStack.pop());
                       result = c.compareTo("+") == 0 ? operand1 + operand2:
                                c.compareTo("-") == 0 ? operand1 - operand2:
                                c.compareTo("*") == 0 ? operand1 * operand2:
                                c.compareTo("/") == 0 ? operand1 / operand2:
                                                        operand1 % operand2;
                myStack.push(Double.toString(result));              
            }
            
        }
        return result;
    }
    
    private static int precedence(String operator)
    {
        switch(operator){
            case "(": case ")": return 0;
            case "+": case "-": return 1;
            case "*": case "/": case "%": return 2;
            case "^": return 3;
            case "=": return 4;
        }
        return -1;
    }
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
     
public class Calculator extends JFrame implements WindowListener,ActionListener {
 
        /* create text boxes */
        TextField Box1 = new TextField(60);
        TextField Box2 = new TextField(60);
        TextField Box3 = new TextField(60);
        String Row1 = " ";        
        String Row2 = " ";        
        String Row3 = " ";
        
        /* create some buttons */
        Button OpenP;
        Button CloseP;
        Button One;
        Button Two;
        Button Three;
        Button Four;
        Button Five;
        Button Six;
        Button Seven;
        Button Eight;
        Button Nine;
        Button Zero;
        Button Dot;
        Button Plus;
        Button Minus;
        Button Divide;
        Button Multiply;
        Button Mod;
        Button Equals;
        Button Exponent;
        
        /* add some labels */
        JLabel EMP = new JLabel    ("Input ");            
        JLabel RPN = new JLabel    ("RPN   ");        
        JLabel Result = new JLabel ("Result");
        
        boolean equalSet = false;
       
        public static void main(String[] args) {
                /* Create a new JFrame with this title */        
                Calculator myFrame = new Calculator("My Calculator");
                
                /* set the size of the frame in number of pixzels */        
                myFrame.setSize(370, 350);
                
                /* display the frame */        
                myFrame.setVisible(true);
        }
        
        /*****************************************************************/
        /* constructor for jframeTest                                    */        
        public Calculator (String title) {
 
                /* send the title to the super */
                super(title);          
                  
                /* this is the pattern that the button are laid out as */
                /* this is just linear */
                //setLayout(new FlowLayout());
                
                /* max number of rows of elements on a panel */
                /* then the number of columns ; 0 = any number */
                // setLayout(new GridLayout(0, 4));  
                 
                setLayout(null);  
                 
  
                addWindowListener(this);
                
                /* label each button with the task it will invoke*/
                OpenP = new Button("(");                          
                CloseP = new Button(")");                          
                One = new Button("1");                
                Two = new Button("2");                
                Three = new Button("3");                
                Four = new Button("4");                
                Five = new Button("5");                
                Six = new Button("6");                
                Seven = new Button("7");                
                Eight = new Button("8");                
                Nine = new Button("9");               
                Zero = new Button("0");                
                Plus = new Button("+");                
                Minus = new Button("-");                
                Divide = new Button("/");                
                Multiply = new Button("*"); 
                Mod = new Button("%");
                Equals = new Button("=");                
                Dot = new Button(".");
                Exponent = new Button("^");
                
                /* Top row of calculator */ 
                Seven.setBounds(0,0,50,50);
                Seven.setBackground(Color.WHITE);
                Eight.setBounds(51,0,50,50);                    
                Eight.setBackground(Color.WHITE);                 
                Nine.setBounds(102,0,50,50);  
                Nine.setBackground(Color.WHITE);
                OpenP.setBounds(173,0,50,50);
                OpenP.setBackground(Color.PINK);
                CloseP.setBounds(224,0,50,50);
                CloseP.setBackground(Color.PINK);
                Exponent.setBounds(275,0,50,50);                 
                Exponent.setBackground(Color.GREEN); 
                
                /* second row of calculator */
                Four.setBounds(0,51,50,50);
                Four.setBackground(Color.WHITE);
                Five.setBounds(51,51,50,50);   
                Five.setBackground(Color.WHITE);
                Six.setBounds(102,51,50,50);   
                Six.setBackground(Color.WHITE);   
                Multiply.setBounds(173,51,50,50); 
                Divide.setBounds(224,51,50,50); 
                Mod.setBounds(274,51,50,50);
                Multiply.setBackground(Color.YELLOW);
                Divide.setBackground(Color.YELLOW);
                Mod.setBackground(Color.YELLOW);
                                
                /* third row of calculator */
                One.setBounds(0,102,50,50);
                One.setBackground(Color.WHITE);  
                Two.setBounds(51,102,50,50);  
                Two.setBackground(Color.WHITE);      
                Three.setBounds(102,102,50,50); 
                Three.setBackground(Color.WHITE);  
                Plus.setBounds(173,102,50,50); 
                Minus.setBounds(224,102,50,50); 
                Equals.setBounds(275,102,50,50); 
                Plus.setBackground(Color.CYAN);
                Minus.setBackground(Color.CYAN);
                Equals.setBackground(Color.RED);
                
                /* fourth row of calculator */
                Zero.setBounds(0,153,100,50);                
                Zero.setBackground(Color.WHITE);  
                Dot.setBounds(102,153,50,50);                    
                Dot.setBackground(Color.WHITE);                                  
                
                /* display boxes */                                         
                EMP.setBounds(0,204,250,30);                          
                RPN.setBounds(0,235,250,30);                           
                Result.setBounds(0,270,250, 30);               
                Box1.setBounds(50,204,250,30);                          
                Box2.setBounds(50,235,250,30);                           
                Box3.setBounds(50,270,250, 30);               
                
                /* add each button to the frame */
                add(Seven);                
                add(Eight);
                add(Nine);                 
                add(OpenP);  
                add(CloseP);
 
                add(Four);                
                add(Five);                
                add(Six); 
                add(Multiply); 
                add(Mod);
                add(Divide);
          
                add(One);                
                add(Two);                
                add(Three);                
                add(Plus);                  
                add(Minus);
                                 
                add(Zero);                        
                add(Dot);
                add(Exponent);                      
                add(Equals);                    
 
                /* add the text boxes to the frame */
                add(Box1);                
                add(Box2);               
                add(Box3);
                add(EMP);                
                add(RPN);
                add(Result);
                
               
                One.addActionListener(this);                
                Two.addActionListener(this);                
                Three.addActionListener(this);                
                Four.addActionListener(this);               
                Five.addActionListener(this);                
                Six.addActionListener(this);                
                Seven.addActionListener(this);                
                Eight.addActionListener(this);                
                Nine.addActionListener(this);                
                Zero.addActionListener(this);                
                Plus.addActionListener(this);                
                Minus.addActionListener(this);                
                Multiply.addActionListener(this); 
                Mod.addActionListener(this);
                Divide.addActionListener(this);                
                Dot.addActionListener(this);                
                Exponent.addActionListener(this);                        
                OpenP.addActionListener(this);                      
                CloseP.addActionListener(this);                      
                Equals.addActionListener(this);                
        }
        
        /**************************************************/
        /* These are the action/events for a given button */
        /* Take action when the button is selected        */
        /* The button is identified by its action command */
        /* The action command is the label of the button   */
        public void actionPerformed(ActionEvent e) {
          Box2.setText(" ");      // clear the previous expression      
          Box3.setText(" ");      // clear the previous result
          
          /* Row1 is used to build a String to pass to the Evaluator as a constructor parameter.
           * Box1 is used to display the String asa it is being built
           */
          
          // put the numeric values in the queue (String)
          if ("1".equals(e.getActionCommand())) {
            Row1 += '1';                 
          
           } else if ("2".equals(e.getActionCommand())) {
            Row1 += '2';           
            
           } else if ("3".equals(e.getActionCommand())) {
            Row1 += '3';           
 
           } else if ("4".equals(e.getActionCommand())) {
            Row1 += '4';  
 
           } else if ("5".equals(e.getActionCommand())) {
            Row1 += '5';  
 
           } else if ("6".equals(e.getActionCommand())) {
            Row1 += '6';  
            
           } else if ("7".equals(e.getActionCommand())) {
            Row1 += '7';  
 
           } else if ("8".equals(e.getActionCommand())) {
            Row1 += '8';  
 
           } else if ("9".equals(e.getActionCommand())) {
            Row1 += '9';  
 
           } else if ("0".equals(e.getActionCommand())) {
            Row1 += '0';  
 
           } else if (".".equals(e.getActionCommand())) {
            Row1 += '.';  
 
           // In this next sections -- put operators in the queue (String)
           } else if ("^".equals(e.getActionCommand())) {
            Row1 += " ^ ";
                
           } else if ("+".equals(e.getActionCommand())) {
            Row1 += " + ";  
 
           } else if ("-".equals(e.getActionCommand())) {
            Row1 += " - ";  
 
           } else if ("*".equals(e.getActionCommand())) {
            Row1 += " * ";  
 
           } else if ("/".equals(e.getActionCommand())) {
            Row1 += " / ";  
 
           } else if ("%".equals(e.getActionCommand())) {
            Row1 += " % ";  
 
           } else if ("(".equals(e.getActionCommand())) {
            Row1 += " ( ";  
                   
           } else if (")".equals(e.getActionCommand())) {
            Row1 += " ) ";  
 
           // put the final item in the queue (String) to trigger the evaluation          
           } else if ("=".equals(e.getActionCommand())) {
            Row1 += " = ";
            equalSet = true;
           
            // instantiate a new Evaluator object
            Evaluator go = new Evaluator(Row1); 
            
            // convert to RPN and display it in box 2
            Box2.setText(go.Convert());
            
            // evaluate (compute) the result of the RPN and display in box 3  
            Box3.setText(Double.toString(go.Compute()));   
            //Row1 = " ";           
            
          } else {
            System.out.println(" Error encountered.  No button selected.");
          } 
          
          if (equalSet) {
              Box1.setText(Row1);
              Row1 = " ";
              equalSet = !equalSet;
          } else {
              Box1.setText(Row1);
          }
        }     
 
 
        /***************************************************************************/
        /* these are the events that are acting on the window                      */
        /* these are requireed in order to satisfy the overriding of the interface */
        /* events which are part of the WindowListener                             */
         
        /* Open the frame and report that it was completed in the textbox  */
        public void windowOpened(WindowEvent e) {
          System.out.println("Window event - openned window");
          Box1.setText("Ready to Calculate");
        }
        
        /* Activate the frame when it is maximized */
        public void windowActivated(WindowEvent e) {
          System.out.println("Window event - activated window");
          Box1.setText("Activated the window");
        }
        
        /* Minimize the frame */
        public void windowIconified(WindowEvent e) { 
          System.out.println("Window event - minimized the window");
          System.out.println("Shrink the window");
        }
          
        /* Maximize the frame */
        public void windowDeiconified(WindowEvent e) { 
          System.out.println("Window event - restored the window size");
          System.out.println("UnShrink the window");
        }
        /* Deactivae the frame when it is iconized */
        public void windowDeactivated(WindowEvent e) {
          System.out.println("Window event - deactivate the window");
          System.out.println("Deactivate the window"); 
        }
             
        /* all done , clean up and go home */
        public void windowClosing(WindowEvent e) {
          System.out.println("Window event - closing window");
          System.out.println("We are now leaving");
          dispose();
          System.exit(0);
        }
        
        /* Close the frame display */
        public void windowClosed(WindowEvent e) {
          /* does not appear because the window already closed */
          System.out.println("We are now gone");
        }
}

else if (operators.contains(c)){
                double operand1 = Double.parseDouble(myStack.pop());
                double operand2 = Double.parseDouble(myStack.pop());
                       result = c.compareTo("+") == 0 ? operand1 + operand2:
                                c.compareTo("-") == 0 ? operand1 - operand2:
                                c.compareTo("*") == 0 ? operand1 * operand2:
                                c.compareTo("/") == 0 ? operand1 / operand2:
                                                        operand1 % operand2;

else if (operators.contains(c)){
                double operand2 = Double.parseDouble(myStack.pop());
                double operand1 = Double.parseDouble(myStack.pop());
                if (c.equalsIgnoreCase("+")){
                    result = operand1 + operand2;
                }
                else if (c.equalsIgnoreCase("-")){
                    result = operand1 - operand2;
                }
                else if (c.equalsIgnoreCase("*")){
                    result = operand1 * operand2;
                }
                else if (c.equalsIgnoreCase("/")){
                    result = operand1 / operand2;
                }
                else if (c.equalsIgnoreCase("^")){
                    result = Math.pow(operand1, operand2);
                }
                else if (c.equalsIgnoreCase("%")){
                    result = operand1 % operand2;
                }