The program is a GUI calculator. For some reason it's having problems with it's equals method. Everything is equal to 4.0 

It's probably something very simple that I'm missing. I feel like I never actually wrote code to tell it how to evaluate things, though I was told that I could evaluate with this algorithm, which I did use (and that's the one I need to use): 
WHILE THERE ARE ANY \* OR / OPERATORS REMAINING
 FIND THE FIRST OCCURANCE OF \* OR / AT INDEX INDEX
 THE OPERANDS WILL BE AT INDEX I AND I+1
 PERFORM THE \* OR / OPERATION ON THOSE 2 OPERANDS
 REPLACE THOSE TWO OPERANDS WITH THE RESULT
 REMOVE THE OPERATOR YOU JUST PEOCESSED FROM THE OPERATORS LIST
END WHILE

GO BACK AND DO THE EXACT SAME LOOP AS ABOVE BUT PROCESS + AND - OPERATORS

IF YOUR EXPRESSION WAS VALID THEN THE FOLLOWING WILL BE TRUE OTHERWISE YOU HAVE BOGUS EXPRESSION
 A) YOU WILL BE LEFT WITH AN EMPTY OPERATORS LIST
 B) THERE WILL BE ONE SOLITARY OPERAND REMAINING IN THE OPERANDS LIST. THAT LAST OPERAND IS THE RESULT OF THE EVALUATION
IF THE ABOVE TWO CONDITIONS ARE NOT TRUE THEN YOUR EXPRESSION WAS BOGUS 

Thanks for any help! 

```
   import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;

public class SimpleCalc
{
    JFrame window;  // the main window which contains everything
    Container content ;
    JButton[] digits = new JButton[12]; 
    JButton[] ops = new JButton[4];
    JTextField expression;
    JButton equals;
    JTextField result;

    public SimpleCalc()
    {
        window = new JFrame( "Simple Calc");
        content = window.getContentPane();
        content.setLayout(new GridLayout(2,1)); // 2 row, 1 col
        ButtonListener listener = new ButtonListener();

        // top panel holds expression field, equals sign and result field  
        // [4+3/2-(5/3.5)+3]  =   [3.456]

        JPanel topPanel = new JPanel();
        topPanel.setLayout(new GridLayout(1,3)); // 1 row, 3 col

        expression = new JTextField();
        expression.setFont(new Font("verdana", Font.BOLD, 16));
        expression.setText("");

        equals = new JButton("=");
        equals.setFont(new Font("verdana", Font.BOLD, 20 ));
        equals.addActionListener( listener ); 

        result = new JTextField();
        result.setFont(new Font("verdana", Font.BOLD, 16));
        result.setText("");

        topPanel.add(expression);
        topPanel.add(equals);
        topPanel.add(result);

        // bottom panel holds the digit buttons in the left sub panel and the operators in the right sub panel
        JPanel bottomPanel = new JPanel();
        bottomPanel.setLayout(new GridLayout(1,2)); // 1 row, 2 col

        JPanel  digitsPanel = new JPanel();
        digitsPanel.setLayout(new GridLayout(4,3)); 

        for (int i=0 ; i<10 ; i++ )
        {
            digits[i] = new JButton( ""+i );
            digitsPanel.add( digits[i] );
            digits[i].addActionListener( listener ); 
        }
        digits[10] = new JButton( "C" );
        digitsPanel.add( digits[10] );
        digits[10].addActionListener( listener ); 

        digits[11] = new JButton( "CE" );
        digitsPanel.add( digits[11] );
        digits[11].addActionListener( listener );       

        JPanel opsPanel = new JPanel();
        opsPanel.setLayout(new GridLayout(4,1));
        String[] opCodes = { "+", "-", "*", "/" };
        for (int i=0 ; i<4 ; i++ )
        {
            ops[i] = new JButton( opCodes[i] );
            opsPanel.add( ops[i] );
            ops[i].addActionListener( listener ); 
        }
        bottomPanel.add( digitsPanel );
        bottomPanel.add( opsPanel );

        content.add( topPanel );
        content.add( bottomPanel );

        window.setSize( 640,480);
        window.setVisible( true );
    }

    // We are again using an inner class here so that we can access
    // components from within the listener.  Note the different ways
    // of getting the int counts into the String of the label

    class ButtonListener implements ActionListener
    {
        public void actionPerformed(ActionEvent e)
        {
            Component whichButton = (Component) e.getSource();
            // how to test for which button?
            // this is why our widgets are 'global' class members
            // so we can refer to them in here

            for (int i=0 ; i<10 ; i++ )
            {
                if (whichButton == digits[i])
                    expression.setText( expression.getText() + i );
            }

                    if (whichButton == ops[0]) 
                        expression.setText(expression.getText() + "+");
            if (whichButton == ops[1]) 
                expression.setText(expression.getText() + "-");
            if (whichButton == ops[2]) 
                expression.setText(expression.getText() + "*");
            if (whichButton == ops[3]) 
                expression.setText(expression.getText() + "/");

            if (whichButton == digits[10]) 
            {
                expression.setText("");
                result.setText("");
            }

            if (whichButton == digits[11]) expression.setText(expression.getText().substring(0, expression.getText().length() -1));

            if (whichButton == equals)
            {
                //if (expression.getText().contains("/0")) result.setText("DIVIDE BY ZERO ERROR");
                result.setText(evaluate());

        }
    }

            // need to add tests for other controls that may have been
            // click that got us in here. Write code to handle those

            // if it was the == button click then
            // result.setText( evaluate() );

        String evaluate()
        {
            if ( !isValid( expression.getText() )) return "INVALID"; // WRITE A ISVALID method
             // WRITE A ISVALID method

                String expr="4+5-12/3.5-5.4*3.14"; // replace with any expression to test
        System.out.println( "expr: " + expr );
        ArrayList<String> operatorList = new ArrayList<String>();
        ArrayList<Double> operandList = new ArrayList<Double>();
        // StringTokenizer is like an infile and calling .hasNext()
        StringTokenizer st = new StringTokenizer( expr,"+-*/", true );
        while (st.hasMoreTokens())
        {
            String token = st.nextToken();
            if ("+-/*".contains(token))
                operatorList.add(token);
            else
                operandList.add( Double.parseDouble( token) );
            }

        while(operandList.contains("*") || operandList.contains("/"))
        {
            int multiply = operandList.indexOf("*");
            int divide = operandList.indexOf("/");

            if(multiply<divide)
            {
                double quotients = (operandList.get(multiply)*operandList.get(multiply+1));
                operandList.set(multiply, quotients);
                operandList.remove(multiply+1);
                operandList.remove(multiply);
            }
            if(divide<multiply)
            {
                double products = (operandList.get(divide)/operandList.get(divide+1));
                operandList.set(divide, products);
                operandList.remove(divide+1);
                operandList.remove(divide);
            }

        }
        while(operandList.contains("+")||operandList.contains("-"))
        {
            int add = operandList.indexOf("+");
            int subtract = operandList.indexOf("-");

            if(add<subtract)
            {
                double adds = (operandList.get(add)+operandList.get(add+1));
                operandList.set(add, adds);
                operandList.remove(add+1);
                operandList.remove(add);
            }
            if(subtract<add)
            {
                double subs = (operandList.get(subtract)-operandList.get(subtract+1));
                operandList.set(subtract, subs);
                operandList.remove(subtract+1);
                operandList.remove(subtract);
            }
        }
        return (" " + operandList.get(0));

        }
        boolean isValid( String expr )
        {   

            if(expr.matches("[a-zA-Z]+")==false) return true; 
            else if(expr.startsWith("+")||expr.startsWith("-")||expr.startsWith("*")||expr.startsWith("/")==false) return true;
            else if(expr.endsWith("+")||expr.endsWith("-")||expr.endsWith("*")||expr.endsWith("/")==false) return true;
            if(expr.matches("[0-9]/0")==false) return true; 

            //test for no chars other than 0123456789+-*/
            //no operator at fornt of back of expr
            //no two ops in a row
            //no divide by zero
            //else return false
            else return false;
        }
    } // END BUTTON LISTNER
    public static void main(String [] args)
    {
        new SimpleCalc();
    }
}

```