Stack Problem

[eric elysia]

Hello,

I am having some problems understanding the use of Objects in a stack.
I am getting errors for these lines:
//stack.push( st.nextToken() );
//y = stack.pop();
//x = stack.pop();

Should I be converting to an Integer here?
Thanks,
Eric

import java.awt.*;
import java.awt.event.*;
import java.text.DecimalFormat;
import java.lang.*;
import javax.swing.*;
import java.util.StringTokenizer;
 
public class ModifiedStackCompositionTest {
 
   public static void main( String args[] )
   {
      ModifiedStackComposition stack = new ModifiedStackComposition();  

Integer result = new Integer( 0 );
Integer x = new Integer( 0 );
Integer y = new Integer( 0 );

String userInput = "11 22+33*";
String operators = " +-*/^%";

StringBuffer postfixSB = new StringBuffer( userInput );;
postfixSB.append( ")" );

StringBuffer digits;

String postfixString = postfixSB.toString();

StringTokenizer st = new StringTokenizer( postfixString, operators, true );

while( st.hasMoreTokens() )
{
for( int i = 0; postfixSB.charAt( i ) != ')'; i++ )
{
if( Character.isDigit( postfixSB.charAt( i ) ) )
{
digits = new StringBuffer();
if( Character.isDigit( postfixSB.charAt( i ) ) )
{
do
{
digits.append( postfixSB.charAt( i ) );
i++;
} while( Character.isDigit( postfixSB.charAt( i ) ) );
i--;
}
//stack.push( st.nextToken() );
}
else if( stack.isOperator( postfixSB.charAt( i ) ) )
{
//y = stack.pop();
//x = stack.pop();
stack.push( stack.calculate( x, y, postfixSB.charAt( i ) ) );
}
}
}

      // remove items from stack
      try 
{
         Object removedObject = null;
 
         while ( true ) 
{
            removedObject = stack.pop(); // use pop method
            System.out.println( removedObject.toString() + " popped" );
            stack.print();
         }
      }
 
      // catch exception if stack is empty when item popped
      catch ( EmptyListException emptyListException ) 
{
         emptyListException.printStackTrace();
      }
   }
} // end class StackCompositionTest
 

[Jean-Sebastien Abella]

Hi Eric,
Yes you need to Cast it before you can assign it to your Integer object.
the function pop of stack return an object.

The reason for that is that you can put anything in the stack so it can only assume it will be an Object.

so in the code it should looks like that:
x = (Integer) stack.pop();


It is the same for ArrayList or Vectors when you call the function get, actually any object of the Collection API.

[eric elysia]

Hello Jean,

Thank you for the help.

I have written it to cast as you suggested, but now I am getting this:

Exception in thread "main" java.lang.ClassCastException: java.lang.String
at postFixEvaluatorPackage.ModifiedStackCompositionTest.main(ModifiedStackCompositionTest.java:53)

Thanks,
Eric
[ August 11, 2005: Message edited by: eric elysia ]

[Jean-Sebastien Abella]

This means that at line 52 you have cast that failed because you tryed to cast something (probably Integer) but it is a String.

[Layne Lund]

So what are you pushing onto the stack? Even if pop() is declared to return an Object, the Object is also the same type as what was pushed onto the stack originally. You are only allowed to cast the return value to the same type as what was originally pushed on or any superclass of this type.

Layne

[eric elysia]

I thought there was a way to cast the object that is being pushed onto the stack.

Eric

[Jean-Sebastien Abella]

Hi Eric,
When you push it doesn't matter as long as the thing you push is an Object, this is because the function push take an Object in parameter. So what is an object? Everything except int,float,char,long,double,short and bool.

Since the Stack as no clue after the push of what type of Object is it will simply pop it back as an object. But it doesnt matter since you should know what you put in the stack.

[eric elysia]

OK, I have revised my program. I feel like I am getting in over my head.

I hope I am on the right track here. I am now working on displaying the output.

Your comments are welcomed.

Thanks,
Eric

package postFixEvaluatorPackage;
 
import postFixEvaluatorPackage.StackInheritance;
import postFixEvaluatorPackage.EmptyListException;
 
import java.awt.*;
import java.awt.event.*;
import java.text.DecimalFormat;
import java.lang.*;
import javax.swing.*;
import java.util.*;
 
public class PostfixEvaluatorTester1 extends JFrame
{
 
StackComposition stack = new StackComposition();
 
private String userInput = "";
private String output = "";
private String testCaseOutput = "";

//public int result = 0;
//public int x = 0;
//public int y = 0;

StringBuffer postfixSB = new StringBuffer();
//StringBuffer digits;

char charArray[] = new char[ postfixSB.length()];


private StringTokenizer strTokenizer;// to allow the string to be broken into tokens
private Token tok;// Token object

private static final int ADD = 1;
private static final int SUBTRACT = 2;
private static final int MULTIPLY = 3;
private static final int DIVIDE = 4;
private static final int EXPONENT = 5;
private static final int REMAINDER = 6;
private static final int RIGHT_PARENTHESIS = 7;
private static final int NUMBER = 8;

// setting up the GUI
private JTextArea outputArea, testCaseOutputArea;
private JTextField postfixExpressionField;

public PostfixEvaluatorTester1()
{
super( "Postfix Evaluator");

Container container = getContentPane();

outputArea = new JTextArea();
outputArea.setEditable( false );

testCaseOutputArea = new JTextArea();
testCaseOutputArea.setEditable( false );

// create panels
JPanel topPanel = new JPanel();
topPanel.setLayout( new GridLayout( 4, 4, 0, 3 ) );
topPanel.setBackground( Color.YELLOW );

JPanel middlePanel = new JPanel();
//middlePanel.setLayout( new GridLayout( 4, 4, 0, 3 ) );
middlePanel.setBackground( Color.YELLOW );

JPanel bottomPanel = new JPanel();
bottomPanel.setLayout( new GridLayout( 4, 4, 0, 3 ) );
bottomPanel.setBackground( Color.YELLOW );

// create components for top panel
JLabel postfixExpressionLabel = new JLabel( "Postfix Expression", SwingConstants.LEFT );
postfixExpressionField = new JTextField( 30 );// Input field
postfixExpressionField.addActionListener
(
new ActionListener()
{

public void actionPerformed( ActionEvent event )
{

clearOutputDisplay();
clearTestCaseOutputDisplay();
setInput( postfixExpressionField.getText() );

StringBuffer strBuffer = new StringBuffer( ( userInput + ")" ) );
char charArray[] = new char[strBuffer.length()];
strBuffer.getChars( 0, strBuffer.length(), charArray, 0 );

testCaseOutput += "The characters are: ";
for( int count = 0; count < charArray.length; ++count )
{
testCaseOutput+= charArray[ count ];
}
testCaseOutput += "\nString Buffer = " + strBuffer.toString();
testCaseOutput += "\nString Buffer Length = " + strBuffer.length();
testCaseOutput += "\nString Buffer Capacity = " + strBuffer.capacity();
displayTestCaseOutput();

getToken( userInput );
evaluatePostfixExpression( userInput );





displayOutput();
}

}

);

JButton calculateButton = new JButton( "Calculate" );// calculate button
calculateButton.addActionListener
(

new ActionListener()
{

public void actionPerformed( ActionEvent event )
{

clearOutputDisplay();// start with clear output area
clearTestCaseOutputDisplay();// start with clear test case output area
setInput( postfixExpressionField.getText() );// get user input and set it to 

StringBuffer strBuffer = new StringBuffer( ( userInput + ")" ) );// read user input into string buffer and append right parenthesis
char charArray[] = new char[strBuffer.length()];// create new character array
strBuffer.getChars( 0, strBuffer.length(), charArray, 0 );// copy string buffer to character array

// display test case output
testCaseOutput += "The characters are: ";// test test case output area
for( int count = 0; count < charArray.length; ++count )// test the character array
{
testCaseOutput+= charArray[ count ];
}
testCaseOutput += "\nString Buffer = " + strBuffer.toString();// display string buffer
testCaseOutput += "\nString Buffer Length = " + strBuffer.length();// display string buffer length
testCaseOutput += "\nString Buffer Capacity = " + strBuffer.capacity();// display string buffer capacity
displayTestCaseOutput();






// display output
displayOutput();

}

}

);

// add components to top panel
topPanel.add( postfixExpressionLabel );
topPanel.add( postfixExpressionField );
topPanel.add( calculateButton );

// create components for middle panel and add them to middle panel
middlePanel.add( testCaseOutputArea );

// create components for bottom panel
JLabel outputLabel = new JLabel( "Output", SwingConstants.LEFT );
bottomPanel.add( outputLabel );
bottomPanel.add( outputArea );
JButton clearOutputButton = new JButton( "Clear Output" );
JButton resetButton = new JButton( "Reset" );

clearOutputButton.addActionListener
(

new ActionListener()
{

public void actionPerformed( ActionEvent event )
{

clearOutputDisplay();
displayOutput();

}

}

);

resetButton.addActionListener
(

new ActionListener()
{

public void actionPerformed( ActionEvent event )
{

userInput = "";
setInput( "" );
clearOutputDisplay();
displayOutput();
clearTestCaseOutputDisplay();
displayTestCaseOutput();

}

}

);

// add components to bottom panel
bottomPanel.add( clearOutputButton );
bottomPanel.add( resetButton );

// create myContainer and add panels to myContainer
Container myContainer = getContentPane();
myContainer.setLayout( new BorderLayout() );
myContainer.add( topPanel, BorderLayout.NORTH );
myContainer.add( middlePanel, BorderLayout.CENTER );
myContainer.add( bottomPanel, BorderLayout.SOUTH );

setSize( 500, 500 );
setVisible( true );

displayOutput();

}

// set output text to output area
private void displayOutput()
{

outputArea.setText( output );

}

// clear output area
private void clearOutputDisplay()
{
output = "";
outputArea.setText( output );
}

// set test case output to test case output area
private void displayTestCaseOutput()
{

displayCharArray();
testCaseOutputArea.setText( testCaseOutput );

}

// clear test case output area
private void clearTestCaseOutputDisplay()
{

testCaseOutput = "";
testCaseOutputArea.setText( testCaseOutput );

}

// display char array
private void displayCharArray()
{

testCaseOutput += "\n";
for( int count = 0; count < charArray.length; ++count )
{

testCaseOutput += charArray[ count ];
testCaseOutput += " ";

}

}

// create stack
private void createStack()
{

StackComposition stack = new StackComposition();

for( int count = 0; count < charArray.length; ++count )
{

stack.push( charArray[ count ] );
stack.print();

}

}

// print stack
private void printStack()
{

for( int count = 0; count < charArray.length; ++count )
{

//output += charArray[count];
stack.print();

}

}

// set input
public void setInput( String inputString )
{

userInput = inputString;

}
 
// get input
public String getInput()
{

return userInput;

}

// get token
private Token getToken( String userInput )
{

if( userInput.equals( "+" ) )
{

tok = new Token( ADD );
return( tok );

}
if( userInput.equals( "-" ) )
{

tok = new Token( SUBTRACT );
return( tok );

}
if( userInput.equals( "*" ) )
{

tok = new Token( MULTIPLY );
return( tok );

}
if( userInput.equals( "/" ) )
{

tok = new Token( DIVIDE );
return( tok );

}
if( userInput.equals( "^" ) )
{

tok = new Token( EXPONENT );
return( tok );

}
if( userInput.equals( "%" ) )
{

tok = new Token( REMAINDER );
return( tok );

}
if( userInput.equals( ")" ) )
{
tok = new Token( RIGHT_PARENTHESIS );
return( tok );
}
else
{

tok = new Token( NUMBER, ( double )Double.valueOf( userInput ).doubleValue() );
return( tok );

}

}

// evaluate postfix expression
private double evaluatePostfixExpression( String userInput )
{

Token tok;
String nextTok;
strTokenizer = new StringTokenizer( userInput );
postfixSB.append( ")" );
printStack();

double result = 0;
double x;
double y;

while( strTokenizer.hasMoreTokens() )
{

nextTok = strTokenizer.nextToken();
tok = getToken( nextTok );

if( tok.getToken() == NUMBER )
{

stack.push( new Double( tok.getValue() ) );
stack.print();

}
else
{

y = ( ( Double )stack.pop() ).doubleValue();
x = ( ( Double )stack.pop() ).doubleValue();

switch( tok.getToken() )
{

case ADD:result = x + y;
break;

case SUBTRACT:result = x - y;
break;

case MULTIPLY:result = x * y;
break;

case DIVIDE:result = x / y;
break;

case EXPONENT:result = Math.pow( x, y );
break;

case REMAINDER:result = x % y;
break;

case RIGHT_PARENTHESIS:

}

stack.push( new Double( result ) );

}

}

result = ( ( Double )stack.pop() ).doubleValue();
return( result );

}

// main
public static void main( String args[] )
{

PostfixEvaluatorTester1 pet = new PostfixEvaluatorTester1();
pet.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

}

}






 

[Layne Lund]

Originally posted by eric elysia:
I thought there was a way to cast the object that is being pushed onto the stack.

Eric

Yes there is and Jean-Sebastion showed you how to do it. The problem is that you have to cast it back to the same type as whatever you originally pused onto the stack. It looks like in your original code you are pushing Strings onto the stack and then trying to cast them to Integers. Since a String cannot be cast to an Integer you are (were?) getting the ClassCastException. I haven't looked closely at your newest bit of code so I don't know if you fixed this particular issue.

So how does the new code work? Does it compile? If so what happens when you run it? If not, what compiler errors do you get? Please provide us some information to work with. I will be happy to help if you can give me some idea of what part of the code I need to look at.

Layne

[eric elysia]

Layne,

The new code does compile and run.

My testCaseOutput is displaying correctly.

I do not have output displaying anything yet.

I am not sure whether the evaluatePostfixExpression method is correct.

I am in the process of walking back through my code to make sure it is doing what I want it to do.

I would like to test the stack first to make sure the string buffer can be read into the stack.

I also want to add exceptions to this program.

Thank you,
Eric

[eric elysia]

After looking over the code, here are some things I need help with.

If I input anything other than a number, I get a NumberFormatException.

Method displayCharArray() is not able to be invoked.

Method printStack() calls method print() in the List class. I need to be able to set this as output.

I'm not sure if I need method createStack(). I just wrote it to see if I might be able to use it.

Eric
[ August 12, 2005: Message edited by: eric elysia ]

[eric elysia]

I am getting the NumberFormatException because I call method getToken(), and token is an int in class Token.

package postFixEvaluatorPackage;
 
class Token {
  private int token;
  private double value;
  
  Token(int t) {
     token = t;
  }
  Token(int t,double x) {
     token = t;
     value = x;
  }
  int getToken() {
    return(token);
  }
  double getValue() {
    return(value);
  }
}

I'm not sure what I need to change to allow operators to be input as well as numbers.

Thanks,
Eric
[ August 13, 2005: Message edited by: eric elysia ]

[eric elysia]

My main questions are:

If I input anything other than a number, I get a NumberFormatException. I realize that this is happening because the method getToken() returns an int. How do I allow operators to be input?

Method displayCharArray() is not able to be invoked. I have tried this also with an array as a parameter, but it is still not being invoked. Any suggestions?

Method printStack() calls method print() in the List class. This is printing the stack to the Run I/O of the compiler, but I need to be able to set this as output. I am not sure how to do this.

Thanks,
Eric

[Layne Lund]

Nothing in the Token class shown will cause the NumberFormatException that you describe, especially not the getToken() method that returns an int. I think you need to step back a second and describe what this Token class represents. In particular, I see that it contains two fields: token and value. What are these for? Did you write this class yourself or was it given by your professor? In either case, you need to understand how it is intended to be used. At this point, I am only able to guess what the intention of this class is, so I would much rather you explain it. I'll be glad to help you from there.

Layne

[eric elysia]

Hello Layne,

The Token class is part of an example program that I found online. The List class and StackComposition class were given in my text and must be used to maintain the PostfixEvaluator class.

The Token class was created to to represent a Token object. The class uses two variables, int token, which is used to represent the token by number, and double value, which is the actual value of the token. The Token class has two constructors. The first constructor takes one int argument, which assigns the int argument to token. The second constructor takes two arguments, int and double, which assigns the int argument to token and the double argument to value. Method getToken returns the current value of token. Method getValue returns the current value of value.

Eric
[ August 13, 2005: Message edited by: eric elysia ]

[eric elysia]

If it helps, this is the original program that I am trying to use as a guide:

import java.io.*;
import java.util.Stack;
import java.util.*; // necessary for StringTokenizer
import java.lang.*;
 
class Token {
  private int token;
  private double value;
  
  Token(int t) {
     token = t;
  }
  Token(int t,double x) {
     token = t;
     value = x;
  }
  int getToken() {
    return(token);
  }
  double getValue() {
    return(value);
  }
}
 
class PostfixEvaluator {
   public static BufferedReader inFile = new BufferedReader
                            (new InputStreamReader(System.in));
   private static String s; 
   private static Stack stack;
   private static StringTokenizer t;
   private static Token tok;
 
   // tokens
   private static final int PLUS     = 0;
   private static final int SUB      = 1;
   private static final int TIMES    = 2;
   private static final int DIV      = 3;
   private static final int NUMBER   = 4;
   private static Token getToken(String s) {
      if (s.equals("+")) {
         tok = new Token(PLUS);
         return(tok);
      }
      if (s.equals("-")) {
         tok = new Token(SUB);
         return(tok);
      }
      if (s.equals("*")) {
         tok = new Token(TIMES);
         return(tok);
      }
      if (s.equals("/")) {
         tok = new Token(DIV);
         return(tok);
      }
      tok = new Token(NUMBER,
           (double) Double.valueOf(s).doubleValue());
      return(tok);
   }
 
   private static double evaluator (String s) {
        Token tok;
        String r;
        t = new StringTokenizer(s);
        double m=0,x,y;
 
         while (t.hasMoreTokens())  {
            r = t.nextToken();
            tok = getToken(r);
            if ( tok.getToken() == NUMBER ) 
                stack.push(new Double(tok.getValue()));
            else {
                y = ( (Double) stack.pop()).doubleValue();
                x = ( (Double) stack.pop()).doubleValue();
                  // WARNING - note order of x,y in stack and operation!
                switch ( tok.getToken() ) {
                    case PLUS  : m = x+y; break;
                    case SUB   : m = x-y; break;
                    case TIMES : m = x*y; break;
                    case DIV   : m = x/y; break;
                }
                stack.push(new Double(m));
            }
         } // end of while
         m = ( (Double) stack.pop()).doubleValue();
         return(m);
   } // end of evaluator
 
   public static void main(String argv[]) throws IOException { 
      stack = new Stack();      
      while( (s = inFile.readLine()) != null) {
        System.out.println(evaluator(s));
      } // end of while 
 
   } // end of main
     
}

Eric

[eric elysia]

Layne,

Before you reply. Please take a look at my revised code. I think I have made things a little simpler. I think this code will be much easier to work with. I need to try to get this program finished tonight. I am willing to learn as much as I can.

The right parenthesis is only used to tell the program when to stop evaluating. I am really trying to make sure I understand every line of my program, but I am still having these problems. I need some help on where to declare the stack, StringBuffer, and charArray. Is it better to get rid of the charArray and just use the StringBuffer? I am not able to output the results into the output field (or testCaseOutputField). I would like to include an exception that only allows valid input. I would also like to include an empty list exception.

Eric

import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import javax.swing.*;
import java.util.*;
 
public class PostfixEvaluatorTester1 extends JFrame
{
StackComposition stack = new StackComposition();
private String userInput = "";
private String output = "";
private String testCaseOutput = "";
private String currentToken = "";
private char currentChar = ' ';
StringBuffer strBuffer;
char charArray[] = new char[ strBuffer.length()];

// setting up the GUI
private JTextArea outputArea, testCaseOutputArea;
private JTextField postfixExpressionField;

public PostfixEvaluatorTester1()
{
super( "Postfix Evaluator");
Container container = getContentPane();
outputArea = new JTextArea();
outputArea.setEditable( false );
testCaseOutputArea = new JTextArea();
testCaseOutputArea.setEditable( false );

// create panels
JPanel topPanel = new JPanel();
topPanel.setLayout( new GridLayout( 4, 4, 0, 3 ) );
topPanel.setBackground( Color.YELLOW );
JPanel middlePanel = new JPanel();
middlePanel.setBackground( Color.YELLOW );
JPanel bottomPanel = new JPanel();
bottomPanel.setLayout( new GridLayout( 4, 4, 0, 3 ) );
bottomPanel.setBackground( Color.YELLOW );

// create components for top panel
JLabel postfixExpressionLabel = new JLabel( "Postfix Expression", SwingConstants.LEFT );
postfixExpressionField = new JTextField( 30 );// Input field
postfixExpressionField.addActionListener
(
new ActionListener()
{
public void actionPerformed( ActionEvent event )
{
clearOutputDisplay();
clearTestCaseOutputDisplay();
setInput( postfixExpressionField.getText() );

strBuffer = new StringBuffer( ( userInput + ")" ) );
char charArray[] = new char[strBuffer.length()];
strBuffer.getChars( 0, strBuffer.length(), charArray, 0 );

testCaseOutput += "The characters are: ";
//displayCharArray( charArray );
for( int count = 0; count < charArray.length; ++count )
{
testCaseOutput+= charArray[ count ];
}
testCaseOutput += "\nString Buffer = " + strBuffer.toString();
testCaseOutput += "\nString Buffer Length = " + strBuffer.length();
testCaseOutput += "\nString Buffer Capacity = " + strBuffer.capacity();
displayTestCaseOutput();

evaluatePostfixExpression( userInput );

displayOutput();
}
}
);

JButton calculateButton = new JButton( "Calculate" );// calculate button
calculateButton.addActionListener
(
new ActionListener()
{
public void actionPerformed( ActionEvent event )
{
clearOutputDisplay();// start with clear output area
clearTestCaseOutputDisplay();// start with clear test case output area
setInput( postfixExpressionField.getText() );// get user input and set it to 

StringBuffer strBuffer = new StringBuffer( ( userInput + ")" ) );// read user input into string buffer and append right parenthesis
char charArray[] = new char[strBuffer.length()];// create new character array
strBuffer.getChars( 0, strBuffer.length(), charArray, 0 );// copy string buffer to character array

// display test case output
testCaseOutput += "The characters are: ";// test test case output area
//displayCharArray( charArray );
for( int count = 0; count < charArray.length; ++count )// test the character array
{
testCaseOutput+= charArray[ count ];
}
testCaseOutput += "\nString Buffer = " + strBuffer.toString();// display string buffer
testCaseOutput += "\nString Buffer Length = " + strBuffer.length();// display string buffer length
testCaseOutput += "\nString Buffer Capacity = " + strBuffer.capacity();// display string buffer capacity
displayTestCaseOutput();

evaluatePostfixExpression( userInput );

// display output
displayOutput();
}
}
);

// add components to top panel
topPanel.add( postfixExpressionLabel );
topPanel.add( postfixExpressionField );
topPanel.add( calculateButton );

// create components for middle panel and add them to middle panel
middlePanel.add( testCaseOutputArea );

// create components for bottom panel
JLabel outputLabel = new JLabel( "Output", SwingConstants.LEFT );

JButton clearOutputButton = new JButton( "Clear Output" );
clearOutputButton.addActionListener
(
new ActionListener()
{
public void actionPerformed( ActionEvent event )
{
clearOutputDisplay();
displayOutput();
}
}
);

JButton resetButton = new JButton( "Reset" );
resetButton.addActionListener
(
new ActionListener()
{
public void actionPerformed( ActionEvent event )
{
userInput = "";
setInput( "" );
postfixExpressionField.setText( userInput );
clearOutputDisplay();
displayOutput();
clearTestCaseOutputDisplay();
displayTestCaseOutput();
}
}
);

// add components to bottom panel
bottomPanel.add( outputLabel );
bottomPanel.add( outputArea );
bottomPanel.add( clearOutputButton );
bottomPanel.add( resetButton );

// create myContainer and add panels to myContainer
Container myContainer = getContentPane();
myContainer.setLayout( new BorderLayout() );
myContainer.add( topPanel, BorderLayout.NORTH );
myContainer.add( middlePanel, BorderLayout.CENTER );
myContainer.add( bottomPanel, BorderLayout.SOUTH );

setSize( 500, 500 );
setVisible( true );

displayOutput();
}

// set output text to output area
private void displayOutput()
{
outputArea.setText( output );
}

// clear output area
private void clearOutputDisplay()
{
output = "";
outputArea.setText( output );
}

// set test case output to test case output area
private void displayTestCaseOutput()
{
testCaseOutputArea.setText( testCaseOutput );
}

// clear test case output area
private void clearTestCaseOutputDisplay()
{
testCaseOutput = "";
testCaseOutputArea.setText( testCaseOutput );
}

// display char array
private void displayCharArray( char cA[] )
{
        testCaseOutput += "\n";
for( int count = 0; count < charArray.length; ++count )
{
testCaseOutput += charArray[ count ];
}
}
 
// print stack
private void printStack()
{
for( int count = 0; count < charArray.length; ++count )
{
//output += charArray[count];
stack.print();
}
}

// set input
private void setInput( String inputString )
{
userInput = inputString;
}
 
// get input
private String getInput()
{
return userInput;
}

// evaluatePostfixExpression
private String evaluatePostfixExpression( String userInput )
{
StringTokenizer strTokenizer = new StringTokenizer( userInput );

try
{
while( strTokenizer.hasMoreTokens() )
{
currentToken = ( String )strTokenizer.nextToken();
currentChar = currentToken.charAt( 0 );

if( isNumber( currentToken ) )
{
stack.push( currentToken );
}
else if( isOperator( currentToken ) )
{
stack.push( calculate( currentToken, stack ) );
}
else if( isRightParenthesis( currentToken ) )
{

}
}
}

catch( Exception e )
{
return null;
}

try
{
Object removedObject = null;

while( strTokenizer.hasMoreTokens() )
{
removedObject = stack.pop();
stack.print();
}
}

catch( EmptyListException emptyListException )
{
emptyListException.printStackTrace();
}

return( String )stack.pop();
}

// isNumber
private boolean isNumber( String number )
{
try
{
Double.parseDouble( number );
return true;
}

catch( Exception e )
{
return false;
}
}

// isOperator
private boolean isOperator( String operator )
{
try
{
if( operator.equals( "+" ) || operator.equals( "-" ) 
|| operator.equals( "*" ) || operator.equals( "/" ) 
|| operator.equals( "%" ) || operator.equals( "^" ) );
{
return true;
}
}

catch( Exception e )
{
return false;
}
}

// isRightParenthesis
private boolean isRightParenthesis( String rightParenthesis )
{
try
{
if( rightParenthesis.equals( ")" ) )
{
return true;
}
}
catch( Exception e )
{
return false;
}
}

// calculate
private String calculate( String operator, StackComposition stack )
{
String returnString = "";
double x;
double y;
double result;

y = Double.parseDouble( ( String )stack.pop() );
x = Double.parseDouble( ( String )stack.pop() );

if( operator.equals( "+" ) )
{
result = x + y;
returnString = new Double( result ).toString();
}
else if( operator.equals( "-" ) )
{
result = x - y;
returnString = new Double( result ).toString();
}
else if( operator.equals( "*" ) )
{
result = x * y;
returnString = new Double( result ).toString();
}
else if( operator.equals( "/" ) )
{
//try         (divide by zero exception)
result = x / y;
returnString = new Double( result ).toString();
}
else if( operator.equals( "^" ) )
{
result = Math.pow( x, y );
returnString = new Double( result ).toString();
}
else if( operator.equals( "%" ) )
{
result = x % y;
returnString = new Double( result ).toString();
}
return returnString;
}

// main
public static void main( String args[] )
{
PostfixEvaluatorTester1 pet = new PostfixEvaluatorTester1();
pet.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
}
 

[ August 14, 2005: Message edited by: eric elysia ]
[ August 14, 2005: Message edited by: eric elysia ]

[Layne Lund]

Originally posted by eric elysia:
...int token, which is used to represent the token by number...

So what does this number MEAN? In other words, what are the possible legal values that can be asigned to this token field? (Hint: take a close look at the source code for this Token class.)

Layne
[ August 14, 2005: Message edited by: Layne Lund ]

[eric elysia]

In the Token class, the int is used to store one of the declared constants from the PostfixEvaluator class, (PLUS, SUB, TIMES, DIV, or NUMBER).

I am no longer using the Token class, but I can use it if you want to continue discussing it.

Thank you,
Eric

[eric elysia]

Layne,

Thank you for your interest in my program. Unfortunately, I have to turn the program in now. Below is the final program that I am submitting.

Eric

import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import javax.swing.*;
import java.util.*;
 
public class PostfixEvaluatorProgram extends JFrame
{
StackComposition stack = new StackComposition();// create new StackComposition object called stack
 
private String userInput = "";// stores input from user
private String output = "";// stores result of postfix evaluation
private String testCaseOutput = "";// stores test case results
private String currentToken = "";// stores the current string token
private char currentChar = ' ';// stores the current char

// setting up the GUI
private JTextField postfixExpressionField;// a place for input
private JTextArea outputArea, testCaseOutputArea;// places for output and test case output

// PostfixEvaluatorTester1 constructor method
public PostfixEvaluatorProgram()
{
super( "Postfix Evaluator");

Container container = getContentPane();

outputArea = new JTextArea();// output area
outputArea.setEditable( false );

testCaseOutputArea = new JTextArea();// test case output area
testCaseOutputArea.setEditable( false );

// create top panel
JPanel topPanel = new JPanel();
topPanel.setLayout( new GridLayout( 4, 4, 0, 3 ) );
topPanel.setBackground( Color.YELLOW );

// create middle panel
JPanel middlePanel = new JPanel();
middlePanel.setBackground( Color.YELLOW );

// create bottom panel
JPanel bottomPanel = new JPanel();
bottomPanel.setLayout( new GridLayout( 4, 4, 0, 3 ) );
bottomPanel.setBackground( Color.YELLOW );

// create components for top panel
JLabel postfixExpressionLabel = new JLabel( "Enter the postfix expression here." , SwingConstants.LEFT );
JLabel postfixFormatLabel = new JLabel( "Use this format: number (space) number (space) operator.  Example:  5 7 + 3 /", SwingConstants.LEFT );
postfixExpressionField = new JTextField( 30 );// input field
postfixExpressionField.addActionListener// add action listener to postfixExpression field
(
new ActionListener()// anonymous inner class
{
public void actionPerformed( ActionEvent event )// handle button event
{

clearOutputDisplay();// clear the output area
clearTestCaseOutputDisplay();// clear the test case output area
setInput( postfixExpressionField.getText() );// get and set user input

StringBuffer strBuffer = new StringBuffer( ( userInput + ")" ) );// read user input into string buffer and append right parenthesis

char charArray[] = new char[ strBuffer.length()];// create new character array

strBuffer.getChars( 0, strBuffer.length(), charArray, 0 );// copy string buffer to character array

testCaseOutput += "The characters are: ";// test the test case output area

for( int count = 0; count < charArray.length; ++count )// test the character array
{
testCaseOutput+= charArray[ count ];
}
testCaseOutput += "\nString Buffer = " + strBuffer.toString();// display string buffer
testCaseOutput += "\nString Buffer Length = " + strBuffer.length();// display string buffer length
testCaseOutput += "\nString Buffer Capacity = " + strBuffer.capacity();// display string buffer capacity

displayTestCaseOutput();// display the test case output

output += evaluatePostfixExpression( userInput );// append evautated input to output


displayOutput();// display output
}
} // end anonymous inner class
); // end call to addActionListener

JButton calculateButton = new JButton( "Calculate" );// calculate button
calculateButton.addActionListener// add action listener to Calculate button
(
new ActionListener()// anonymous inner class
{
public void actionPerformed( ActionEvent event )// handle button event
{
clearOutputDisplay();// clear the output area
clearTestCaseOutputDisplay();// clear the clear test case output area
setInput( postfixExpressionField.getText() );// get and set user input 

StringBuffer strBuffer = new StringBuffer( ( userInput + ")" ) );// read user input into string buffer and append right parenthesis

char charArray[] = new char[strBuffer.length()];// create new character array

strBuffer.getChars( 0, strBuffer.length(), charArray, 0 );// copy string buffer to character array

// display test case output
testCaseOutput += "The characters are: ";// test the test case output area

for( int count = 0; count < charArray.length; ++count )// test the character array
{
testCaseOutput+= charArray[ count ];
}
testCaseOutput += "\nString Buffer = " + strBuffer.toString();// display string buffer
testCaseOutput += "\nString Buffer Length = " + strBuffer.length();// display string buffer length
testCaseOutput += "\nString Buffer Capacity = " + strBuffer.capacity();// display string buffer capacity

displayTestCaseOutput();// display the test case output

output += evaluatePostfixExpression( userInput );// append evaluated input to output


displayOutput();// display output

}

} // end anonymous inner class

); // end call to addActionListener

// add components to top panel
topPanel.add( postfixExpressionLabel );
topPanel.add( postfixFormatLabel );
topPanel.add( postfixExpressionField );
topPanel.add( calculateButton );

// create components for middle panel and add them to middle panel
middlePanel.add( testCaseOutputArea );

// create components for bottom panel
JLabel outputLabel = new JLabel( "Output", SwingConstants.LEFT );

JButton clearOutputButton = new JButton( "Clear Output" );// clear output button
clearOutputButton.addActionListener// add action listener to clear button
(

new ActionListener()// anonymous inner class
{

public void actionPerformed( ActionEvent event )// handle button event
{

clearOutputDisplay();// clear output display
displayOutput();// show clear output display

}

} // end anonymous inner class

); // end call to addActionListener

JButton resetButton = new JButton( "Reset" );// reset button
resetButton.addActionListener// add action listener to reset button
(

new ActionListener()// anonymous inner class
{

public void actionPerformed( ActionEvent event )// handle button event
{

//userInput = "";// reset userInput
setInput( "" );// reset userInput
postfixExpressionField.setText( userInput );// reset postfix expression field
clearOutputDisplay();// clear output display
displayOutput();// show clear output display
clearTestCaseOutputDisplay();// clear test case output display
displayTestCaseOutput();// show clear test case output display

} 

} // end anonymous inner class

); // end call to addActionListener

// add components to bottom panel
bottomPanel.add( outputLabel );
bottomPanel.add( outputArea );
bottomPanel.add( clearOutputButton );
bottomPanel.add( resetButton );

// create myContainer and add panels to myContainer
Container myContainer = getContentPane();
myContainer.setLayout( new BorderLayout() );
myContainer.add( topPanel, BorderLayout.NORTH );
myContainer.add( middlePanel, BorderLayout.CENTER );
myContainer.add( bottomPanel, BorderLayout.SOUTH );

setSize( 700, 500 );
setVisible( true );

displayOutput();// invokes displayOutput method

} // end PostfixEvaluatorTester1 constructor method


// displayOutput method
private void displayOutput()
{

outputArea.setText( output );// sets output to outputArea

} // end displayOutput method


// clearOutputDisplay method
private void clearOutputDisplay()
{
output = "";// assigns empty string to output
outputArea.setText( output );// sets output to outputArea
} // end clearOutputDisplay method


// displayTestCaseOutput method
private void displayTestCaseOutput()
{

testCaseOutputArea.setText( testCaseOutput );// sets testCaseOutput to testCaseOutputArea

} // end displayTestCaseOutput method


// clearTestCaseOutputDisplay method
private void clearTestCaseOutputDisplay()
{

testCaseOutput = "";// assigns empty string to testCaseOutput
testCaseOutputArea.setText( testCaseOutput );// sets testCaseOutput to testCaseOutputArea

} // end clearTestCaseOutputDisplay method

// setInput method
private void setInput( String inputString )
{

userInput = inputString;// assigns inputString to userInput

} // end setInput method
 

// getInput method
private String getInput()
{

return userInput;// returns userInput

} // end getInput method


// evaluatePostfixExpression method
private String evaluatePostfixExpression( String userInput )
{

StringTokenizer strTokenizer = new StringTokenizer( userInput );

try// try to push string tokens onto stack
{
while( strTokenizer.hasMoreTokens() )// while the user input string has more tokens
{
currentToken = ( String )strTokenizer.nextToken();// cast each token to a String
currentChar = currentToken.charAt( 0 );// start with first token

if( isNumber( currentToken ) )// if current token is a number
{
stack.push( currentToken );// push the current token onto the stack
} // end if
else if( isOperator( currentToken ) )// else if the current token is an operator
{
stack.push( calculate( currentToken, stack ) );// push calculated token onto the stack
} // end else if
} // end while
} // end try

catch( Exception e )
{
return null;// if the token is not a number or operator return null
} // end catch

try// try to pop tokens from stack
{
Object removedObject = null;

while( strTokenizer.hasMoreTokens() )// while the user input string has more tokens
{
removedObject = stack.pop();// remove each token from the stack
stack.print();// print  
} // end while
} // end try

catch( EmptyListException emptyListException )
{
emptyListException.printStackTrace();// if the stack is empty, print stack trace
} // end catch

return( String )stack.pop();// return popped token as a string
} // end evaluatePostfixExpression method


// isNumber method
private boolean isNumber( String number )
{
try// try to parse the token to a Double
{
Double.parseDouble( number );
return true;// return true if token can be parsed to a Double
} // end try

catch( Exception e )
{
return false;// return false if token cannot be parsed to a Double
} // end catch
} // end isNumber method


// isOperator method
private boolean isOperator( String operator )
{
try// try to see if the token is an operator
{
if( operator.equals( "+" ) || operator.equals( "-" ) 
|| operator.equals( "*" ) || operator.equals( "/" ) 
|| operator.equals( "%" ) || operator.equals( "^" ) );
{
return true;// return true if the token is an operator
} // end if
} // end try

catch( Exception e )
{
return false;// return false if the token is not an operator
} // end catch
} // end isOperator method



// calculate method
private String calculate( String operator, StackComposition stack )
{
double x;// double to store number popped from stack
double y;// double to store number popped from stack
double result;// double to store result of calculation
String returnString = "";// string to store result as a string

y = Double.parseDouble( ( String )stack.pop() );// top token on stack gets popped into y
x = Double.parseDouble( ( String )stack.pop() );// next token on stack gets popped into x

if( operator.equals( "+" ) )// if operator is the "plus" sign
{
result = x + y;// result is x plus y
returnString = new Double( result ).toString();// convert result to a string and assign to returnString
} // end if
else if( operator.equals( "-" ) )// if operator is the "minus" sign
{
result = x - y;// result is x - y
returnString = new Double( result ).toString();// convert result to a string and assign to returnString
} // end else if
else if( operator.equals( "*" ) )// if operator is the "times" sign
{
result = x * y;// result is x * y
returnString = new Double( result ).toString();// convert result to a string and assign to returnString
} // end else if
else if( operator.equals( "/" ) )// if operator is the "divided by" sign
{
//try         (divide by zero exception)
result = x / y;// result is x / y
returnString = new Double( result ).toString();// convert result to a string and assign to returnString
} // end else if
else if( operator.equals( "^" ) )// if operator is the "to the" sign
{
result = Math.pow( x, y );// result is x ^ y
returnString = new Double( result ).toString();// convert result to a string and assign to returnString
} // end else if 
else if( operator.equals( "%" ) )// if operator is the "modulus" sign
{
result = x % y;// result is x % y 
returnString = new Double( result ).toString();// convert result to a string and assign to returnString
} // end else if
return returnString;// return resultString
} // end calculate method


// main method
public static void main( String args[] )
{

PostfixEvaluatorProgram pep = new PostfixEvaluatorProgram();
pep.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

} // end main method

}