# Calculator

• March 1st, 2011, 07:10 PM
Andrew Wilson
Calculator
Hi, I'm new to Computer Programming and I am trying to determine how to use the postfix to in fix method (instructor gave us) to add, subtract, multiply, and divide numbers for a calculator program.

Heres the code.
Code Java:

```package calculator;   import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.EmptyStackException; import java.util.Scanner; import java.util.Stack; import java.util.logging.Level; import java.util.logging.Logger; import java.util.regex.Pattern; import javax.swing.*;   /** * Main class runs the calculator GUI program and uses * InfixToPostfixParens to use the operants and the operands * to return values on an output textField. * * @author Andrew W. Wilson * @version 2/28/2011 */ public class Main extends JFrame {   // Data Fields /** The operator stack */ private Stack<Character> operatorStack; /** The operators */ private static final String OPERATORS = "-+*/()"; /** * The Pattern to extract tokens * A token is either a string of digits (\d+) * or a JavaIdentifier or an operator */ private static final Pattern pattern = Pattern.compile("\\d+\\.\\d*|\\d+|" + "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*" + "|[" + OPERATORS + "]"); /** The precedence of the operators, matches order of OPERATORS. */ private static final int[] PRECEDENCE = {1, 1, 2, 2, -1, -1}; /** The postfix string */ private StringBuilder postfix; // creates buttons for the user interface JButton one = new JButton("1"); JButton two = new JButton("2"); JButton three = new JButton("3"); JButton four = new JButton("4"); JButton five = new JButton("5"); JButton six = new JButton("6"); JButton seven = new JButton("7"); JButton eight = new JButton("8"); JButton nine = new JButton("9"); JButton zero = new JButton("0"); JButton plus = new JButton("+"); JButton division = new JButton("/"); JButton subtraction = new JButton("-"); JButton multiply = new JButton("*"); JButton clear = new JButton("Clear"); JButton equals = new JButton("="); JButton decimal = new JButton("."); JButton blank = new JButton(" "); int total; String update = ""; // infix string private static final Font BIG = new Font("monspaced", Font.PLAIN, 20); JTextField calculator = new JTextField();   /** * This is the main method which runs the GUI * @param args the command line arguments */ public static void main(String[] args) { // TODO code application logic here JFrame userframe = new Main(); userframe.setVisible(true); }   /** * Creates the calculator's grid */ public Main() { setTitle("Calculator"); setDefaultCloseOperation(EXIT_ON_CLOSE);   Container contentPane = getContentPane();   contentPane.setLayout(new BorderLayout());   // Creates the display field calculator = new JTextField("0", 12); calculator.setHorizontalAlignment(JTextField.RIGHT); calculator.setFont(BIG); // calculator.addActionListener(new AddButtonListener());   JPanel north = new JPanel(); JPanel south = new JPanel(); JPanel east = new JPanel(); JPanel center = new JPanel(); north.setLayout(new GridLayout(0, 1)); south.setLayout(new GridLayout(1, 4)); east.setLayout(new GridLayout(5, 0)); center.setLayout(new GridLayout(4, 3)); north.add(calculator); add(north, BorderLayout.NORTH); add(east, BorderLayout.EAST);   center.add(seven); // Create a GridLayout seven.setFont(BIG); seven.addActionListener(new SevenListener());   clear.setFont(BIG); clear.addActionListener(new ClearListener());   center.add(eight); eight.setFont(BIG); eight.addActionListener(new EightListener());   center.add(nine); nine.setFont(BIG); nine.addActionListener(new NineListener());   center.add(four); four.setFont(BIG); four.addActionListener(new FourListener());   center.add(five); five.setFont(BIG); five.addActionListener(new FiveListener());   center.add(six); six.setFont(BIG); six.addActionListener(new SixListener());   center.add(one); one.setFont(BIG); one.addActionListener(new OneListener());   center.add(two); two.setFont(BIG); two.addActionListener(new TwoListener());   center.add(three); three.setFont(BIG); three.addActionListener(new ThreeListener());   center.add(blank);   center.add(zero); zero.setFont(BIG); zero.addActionListener(new ZeroListener());   center.add(decimal); decimal.setFont(BIG); decimal.addActionListener(new DecimalListener());   east.add(plus); plus.setFont(BIG); plus.addActionListener(new PlusListener());   east.add(multiply); multiply.setFont(BIG); multiply.addActionListener(new TimesListener());   east.add(division); division.setFont(BIG); division.addActionListener(new DivisionListener());   east.add(subtraction); subtraction.setFont(BIG); subtraction.addActionListener(new SubtractionListener());   east.add(equals); equals.setFont(BIG); equals.addActionListener(new EqualsListener());   south.add(clear); add(south, BorderLayout.SOUTH); add(center, BorderLayout.CENTER);   pack(); setLocationRelativeTo(null); }   public String getTotalString() { return "" + total; }   public class SyntaxErrorException extends Exception {   /** * Construct a SyntaxErrorException with the specified * message. * @param message The message */ SyntaxErrorException(String message) { super(message); } }   /** * Convert a string from infix to postfix. * @param infix The infix expression * @throws SyntaxErrorException */ public String convert(String infix) throws SyntaxErrorException { operatorStack = new Stack<Character>(); postfix = new StringBuilder(); Scanner scan = new Scanner(infix); try { // Process each token in the infix string. String nextToken; while ((nextToken = scan.findInLine(pattern)) != null) { char firstChar = nextToken.charAt(0); // Is it an operand? if (Character.isJavaIdentifierStart(firstChar) || Character.isDigit(firstChar)) { postfix.append(nextToken); postfix.append(' '); } // Is it an operator? else if (isOperator(firstChar)) { processOperator(firstChar); } else { throw new SyntaxErrorException("Unexpected Character Encountered: " + firstChar); } } // End while. // Pop any remaining operators // and append them to postfix. while (!operatorStack.empty()) { char op = operatorStack.pop(); // Any '(' on the stack is not matched. if (op == '(') { throw new SyntaxErrorException( "Unmatched opening parenthesis"); } postfix.append(op); postfix.append(' '); } // assert: Stack is empty, return result. return postfix.toString(); } catch (EmptyStackException ex) { throw new SyntaxErrorException("Syntax Error: The stack is empty"); } }   /** * Method to process operators. * @param op The operator * @throws EmptyStackException */ private void processOperator(char op) { if (operatorStack.empty() || op == '(') { operatorStack.push(op); } else { // Peek the operator stack and // let topOp be the top operator. char topOp = operatorStack.peek(); if (precedence(op) > precedence(topOp)) { operatorStack.push(op); } else { // Pop all stacked operators with equal // or higher precedence than op. while (!operatorStack.empty() && precedence(op) <= precedence(topOp)) { operatorStack.pop(); if (topOp == '(') { // Matching '(' popped - exit loop. break; } postfix.append(topOp); postfix.append(' '); if (!operatorStack.empty()) { // Reset topOp. topOp = operatorStack.peek(); } }   // assert: Operator stack is empty or // current operator precedence > // top of stack operator precedence. if (op != ')') { operatorStack.push(op); } } } }   /** * Determine whether a character is an operator. * @param ch The character to be tested * @return true if character is an operator */ private boolean isOperator(char ch) { return OPERATORS.indexOf(ch) != -1; }   /** * Determine the precedence of an operator. * @param op The operator * @return the precedence */ private int precedence(char op) { return PRECEDENCE[OPERATORS.indexOf(op)]; }   public static double evaluatePostfix(String expression) { MyStack evalStack = new MyStack(); String[] split = expression.split(" "); for (int i = 0; i < split.length; i++) { //System.out.println("split[" + i + "] = " + split[i]); if (split[i].equals("+")) { double secondOperand = evalStack.pop().getData(); double firstOperand = evalStack.pop().getData(); double result = firstOperand + secondOperand; evalStack.push(new StackNode(result)); } else if (split[i].equals("-")) { double secondOperand = evalStack.pop().getData(); double firstOperand = evalStack.pop().getData(); double result = firstOperand - secondOperand; evalStack.push(new StackNode(result)); } else if (split[i].equals("*")) { double secondOperand = evalStack.pop().getData(); double firstOperand = evalStack.pop().getData(); double result = firstOperand * secondOperand; evalStack.push(new StackNode(result)); } else if (split[i].equals("/")) { double secondOperand = evalStack.pop().getData(); double firstOperand = evalStack.pop().getData(); double result = firstOperand / secondOperand; evalStack.push(new StackNode(result)); } else { // split[i] is a number (assumption) evalStack.push(new StackNode(Double.parseDouble(split[i]))); } } double expressionValue = evalStack.pop().getData(); return expressionValue; }   /** * OneListener class creates an action for the one button * which allows operations to be used. */ public class OneListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "1"; calculator.setText(update); } }   /** * TwoListener class creates an action for the two button * which allows operations to be used. */ public class TwoListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "2"; calculator.setText(update); } }   /** * ThreeListener class creates an action for the three button * which allows operations to be used. */ public class ThreeListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "3"; calculator.setText(update); } }   /** * FourListener class creates an action for the four button * which allows operations to be used. */ public class FourListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "4"; calculator.setText(update); } }   /** * FiveListener class creates an action for the five button * which allows operations to be used. */ public class FiveListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "5"; calculator.setText(update); } }   /** * SixListener class creates an action for the six button * which allows operations to be used. */ public class SixListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "6"; calculator.setText(update); } }   /** * SevenListener class creates an action for the seven button * which allows operations to be used. */ public class SevenListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "7"; calculator.setText(update); } }   /** * EightListener class creates an action for the eight button * which allows operations to be used. */ public class EightListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "8"; calculator.setText(update); } }   /** * NineListener class creates an action for the nine button * which allows operations to be used. */ public class NineListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "9"; calculator.setText(update); } }   /** * ClearListener class creates an action for the clear button * which allows operations to be used. */ public class ClearListener implements ActionListener {   public void actionPerformed(ActionEvent e) { calculator.setText(" "); } }   /** * PlusListener class creates an action for the + button * which allows operations to be used. */ public class PlusListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "+"; calculator.setText(update); } }   /** * DivisionListener class creates an action for the / button * which allows operations to be used. */ public class DivisionListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "/"; calculator.setText(update); } }   /** * TimesListener class creates an action for the * button * which allows operations to be used. */ public class TimesListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "*"; calculator.setText(update); } }   /** * SubtractionListener class creates an action for the subtraction button * which subtracts values. */ public class SubtractionListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "-"; calculator.setText(update); } }   /** * DecimalListener class creates an action for the decimal button * which allows operations to be used. */ public class DecimalListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "."; calculator.setText(update); } }   /** * ZeroListener class creates an action for the zero button * which allows operations to be used. */ public class ZeroListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String display = calculator.getText(); update = display + "0"; calculator.setText(update); } }   /** * EqualsListener class creates an action for the = button * which allows operations to be used. */ public class EqualsListener implements ActionListener {   public void actionPerformed(ActionEvent e) { String displayText = calculator.getText(); String equalsign = "="; Main number = new Main(); try { if (equalsign.equals("=")) { number.convert(displayText); } else if (equalsign.equals("+")) { number.convert(displayText); } else if (equalsign.equals("-")) { number.convert(displayText); } else if (equalsign.equals("*")) { number.convert(displayText); } else if (equalsign.equals("/")) { number.convert(displayText); } } catch (SyntaxErrorException ex) { Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex); }   calculator.setText(" " + number.getTotalString()); } } }```
• March 2nd, 2011, 07:08 AM
JavaPF
Re: Calculator
Hello Andrew, welcome to the Java Programming Forums.

What is your problem exactly? You need to break it down for us and take it one step at a time.

I suggest reading - Short, Self Contained, Correct Example

I have also moved this thread to the correct forum - What's wrong with my code