Stack Size

Question

For an assignment I had to create a postfix calculator, and one of the errors we had to catch was:
if there is more then one integer left in the stack when printing the final result, it needs
to give an error message and exit.
We were provided the implementation and interface for the Stack by our instructor and here is the method he used for toString.
    public String toString() {
     if (empty()) {
         return "Empty Stack";
     } else {
         return recursiveToString(top);
    /* recursive method to print a non-empty stack
     * @param     the starting index in the array
     * @return     a string representing the stack
    private String recursiveToString(IntNode start) {
     if (start == null) {
         return "";
     String separator = "";
     if (start != top) {
         separator = " :: ";
     return recursiveToString(start.getNext()) +
                start.getValue() + separator;
    }Basically if there is more than one integer in the stack it will print it like so:
1 :: 2 :: 3 :: 4
This is what I used to tell if there was more than one integer left in the stack when printing the final results. I used this code:
//Checking for the "::" that the toString method prints between integers
//when there is more than one left in the stack. If there is more the one
//integer left in the stack then give an error and exit.
for(int i = 0; i < intStack.toString().length(); i++) { //looping through the toString
//if there are two colons, consecutively, there is more than one integer in the stack
     if(intStack.toString().charAt(i) == ':' && intStack.toString().charAt(i+1) == ':') {
          System.out.println("Error:\tMore than one integer in final stack. Make sure equations\n\tin " + param[0] + " are valid. Exiting program...");
          System.exit(1);
}Now my question is... is there a better way to do this? Ideally I would like this part to work regardless
of how the toString method formats the integers. Because right now if the toString method was
changed my little check would not work. So is there a way to determine the amount of items in a stack
or a better way to do this.
To give a better understanding of those snippets here is the code as a whole:
import java.util.EmptyStackException;
import java.util.Scanner;
import java.io.File;
public class KinseyAnthony4 {
     public static void main(String[] param) {
          /** Declare new IntLinkedStack Stack Object */
          IntLinkedStack intStack = new IntLinkedStack();
          //Make sure there is only one parameter entered.
          if(param.length == 1) {
               //try to read the file
               try {
                    /** declaring new file object */
                    File calcMe = new File(param[0]);
                    /** declaring new scanner object */
                    Scanner readIt = new Scanner(calcMe);
                    /** declaring int for line number */
                    int line = 1;
                    /** declaring int for first number popped from stack */
                    int top = 0;
                    /** declaring int for second number popped from stack */
                    int next = 0;
                    /** declaring int to hold the result of calculations */
                    int result = 0;
                    //Report current status
                    System.out.println("Reading through " + param[0] + ":");
                    //Use loop to view each line until there are none left
                    while(readIt.hasNextLine()) {
                        /** declaring string that holds current line's content */
                         String lineContent = readIt.nextLine();
                         //Report current line number and it's contents
                         System.out.println("\nLine " + line + ": " + lineContent);
                         //Use for loop to analyze each character in the line
                         for(int i=0; i < lineContent.length(); i++) {
                              //Is it a digit?
                              if(Character.isDigit(lineContent.charAt(i))) {
                                   /** declaring int that holds numeric value of the char */
                                   int pushMe = Character.getNumericValue(lineContent.charAt(i));
                                   //Report what's being pushed on stack
                                   System.out.println(">Pushing " + pushMe + " to stack.");
                                   //Push the value on the stack
                                   intStack.push(pushMe);
                              //It's not a digit
                              else {
                                   //Use a switch statement for computations
                                   switch(lineContent.charAt(i)) {
                                        //Multiplication
                                        case '*':
                                             top = intStack.pop(); //Pop top number
                                             System.out.println(">Popping " + top + " from stack."); //Status
                                             next = intStack.pop(); //Pop next number
                                             System.out.println(">Popping " + next + " from stack."); //Status
                                             result = next * top; //Multiply them
                                             System.out.println(">Calculating " + next + " * " + top); //Status
                                             intStack.push(result); //Push result back onto stack
                                             System.out.println(">Pushing result of " + result + " to stack."); //Status
                                             break;
                                        //Division
                                        case '/':
                                             top = intStack.pop(); //Pop top number
                                             System.out.println(">Popping " + top + " from stack."); //Status
                                             next = intStack.pop(); //Pop next number
                                             System.out.println(">Popping " + next + " from stack."); //Status
                                             result = next / top; //Divide them
                                             System.out.println(">Calculating " + next + " / " + top); //Status
                                             intStack.push(result); //Push result back onto stack
                                             System.out.println(">Pushing result of " + result + " to stack."); //Status
                                             break;
                                       //Addition
                                        case '+':
                                             top = intStack.pop(); //Pop top number
                                             System.out.println(">Popping " + top + " from stack."); //Status
                                             next = intStack.pop(); //Pop next number
                                             System.out.println(">Popping " + next + " from stack."); //Status
                                             result = next + top; //Add them
                                             System.out.println(">Calculating " + next + " + " + top); //Status
                                             intStack.push(result); //Push result back onto stack
                                             System.out.println(">Pushing result of " + result + " to stack."); //Status
                                             break;     
                                        //Subtraction
                                        case '-':
                                             top = intStack.pop(); //Pop top number
                                             System.out.println(">Popping " + top + " from stack."); //Status
                                             next = intStack.pop(); //Pop next number
                                             System.out.println(">Popping " + next + " from stack."); //Status
                                             result = next - top; //Subtract them
                                             System.out.println(">Calculating " + next + " - " + top); //Status
                                             intStack.push(result); //Push result back onto stack
                                             System.out.println(">Pushing result of " + result + " to stack."); //Status
                                             break;
                                        //Invalid Characters
                                        default:
                                             //Ignore them if they're spaces
                                             if(!Character.isSpaceChar(lineContent.charAt(i))) {
                                                  //So if they're not spaces give an error and exit
                                                  System.out.println("Error:\tInvalid character read. Exiting program...");
                                                  System.exit(1);
                                                  break;
                         //Checking for the "::" that the toString method prints between integers
                         //when there is more than one left in the stack. If there is more the one
                         //integer left in the stack then give an error and exit.
                         for(int i = 0; i < intStack.toString().length(); i++) { //looping through the toString
                              //if there are two colons, consecutively, there is more than one integer in the stack
                              if(intStack.toString().charAt(i) == ':' && intStack.toString().charAt(i+1) == ':') {
                                   System.out.println("Error:\tMore than one integer in final stack. Make sure equations\n\tin " + param[0] + " are valid. Exiting program...");
                                   System.exit(1);
                         //Once it passes that check, print the final calculation
                         System.out.println("***The final result is " + intStack.toString() + "***");
                         //Clear the stack for the following loop
                         while(!intStack.toString().equals("Empty Stack")) {
                              intStack.pop();
                         //Increment the line number and loop back
                         line++;
                    //If it's the end of the file, exit
                    System.exit(1);
               //catch invalid postfix equations
               catch(Exception e) {
                    System.out.println("\nError:\tThe " + e + " occured while reading " + param[0] +".\n\tMake sure equations in " + param[0] + " are valid. Exiting program...");
                    System.exit(1);
          //The user entered more than one parameter
          else {
               //Give the error and exit
               System.out.println("Error:\tToo many parameters. One file name parameter is allowed. " + param.length + " were found. Exiting program...");
               System.exit(1);
/* a stack of ints implemented using a linked list of nodes
* @author     Biagioni, Edoardo
* @assignment     lecture 8 and homework 4
* @date     February 6, 2008
class IntLinkedStack implements IntStackInterface {
    /* only need to store a single pointer to the node holding
     * the top of the stack.
     * The pointer is null if the stack is empty.
    private IntNode top;
    /* no-arguments default constructor creates an empty stack */
    public IntLinkedStack() {
     top = null;          // start with an empty stack
    /* @return     whether the stack is empty */
    public boolean empty() {
     return (top == null);
    /* @param     int to push onto the stack */
    public void push(int value) {
     top = new IntNode(value, top);
    /* @return     the top int on the stack */
    public int pop() throws EmptyStackException {
     if (empty()) {
         throw new EmptyStackException();
     int result = top.getValue();
     top = top.getNext();
     return result;
    /* convert the stack to a printable string
     * @return     a string representing the stack
    public String toString() {
     if (empty()) {
         return "Empty Stack";
     } else {
         return recursiveToString(top);
    /* recursive method to print a non-empty stack
     * @param     the starting index in the array
     * @return     a string representing the stack
    private String recursiveToString(IntNode start) {
     if (start == null) {
         return "";
     String separator = "";
     if (start != top) {
         separator = " :: ";
     return recursiveToString(start.getNext()) +
                start.getValue() + separator;
    // simple test
    public static void main(String[] args) {
     IntStackInterface s = new IntLinkedStack();
     System.out.println("before pushing anything, " + s);
     s.push(999);
     s.push(216);
     System.out.println("after pushing 999 and 216, " + s);
     System.out.println("pop returns " + s.pop());
     System.out.println("after popping, " + s);
     // push 100 values
     for (int i = 0; i < 100; i++) {
         s.push(i);
     // now pop them and make sure the same values are returned
     // in LIFO order
     for (int i = 99; i >= 0; i--) {
         int returned = s.pop();
         if (returned != i) {
          System.out.println("error: pop returns " + returned +
                       ", expected " + i);
     s.push(477);
     s.push(381);
     s.push(888);
     System.out.println("after pushing 477, 381, 888, " + s);
     System.out.println("pop returns " + s.pop());
     System.out.println("pop returns " + s.pop());
     System.out.println("pop returns " + s.pop());
     System.out.println("pop returns " + s.pop());
     System.out.println("after popping, " + s);
     /* expected output:
    private class IntNode {
        /* two fields, the first to store the item itself,
         * the second is a pointer to the next node in the linked list.
      * If there is no next node, the pointer is null.
     private int item;
     private IntNode nextNode;
     /* constructor:
      * @param     value, the value for the node
      * @param     next, the next node in the linked list
     public IntNode(int value, IntNode next) {
         item = value;
         nextNode = next;
     /* accessor methods -- since there are no mutator methods,
      * each node is immutable.
     public int getValue() {
         return item;
     public IntNode getNext() {
         return nextNode;
/* an interface to a stack of ints
* @author     Biagioni, Edoardo
* @assignment     lecture 8 and assignment 4
* @date     February 6, 2008
* @inspiration     William Albritton's integer stack and Java's stack class,
*http://www2.hawaii.edu/~walbritt/ics211/stackArray/IntegerStackInterface.java
* http://java.sun.com/j2se/1.5.0/docs/api/java/util/Stack.html
interface IntStackInterface {
    /* @param     string to push onto the stack */
    void push(int value);
    /* @return     the top string on the stack */
    int pop()
     throws java.util.EmptyStackException;
    /* @return     whether the stack is empty */
    boolean empty();
}and this is the file i tested it on:
98-
1 1 +
7 2 /
8 1 1 + /
2 3 * 1 -
5 5 + 2 2 * -
8 2 / 9 3 / +
2 2 * 2 *
1 2 3 1 + * +
2 6 + 3 - 2 *The outcome should be 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Thanks in advance, any help would be appreciated!

Answer 1

AnthonyJK wrote:
Thanks, I'm working on breaking it into methods now.Good.
I also whipped something up,but I currently don't have access to a compiler so there might be errors in it. It's basically the same as what your big main method does, but in a much more readable manner:
public class KinseyAnthony4 {
     * @param a     the first number
     * @param op    the mathematical operator
     * @param b     the second number
     * @return      the outcome of the expression 'a <op> b'
    private static int evaluate(int a, char op, int b) {
        switch(op) {
        case '+': return a+b;
        case '-': return a-b;
        case '*': return a*b;
        case '/': return a/b;
        default: throw new RuntimeException("Unknown operator: "+op);
     * @param calcMe    the File in which the expressions are stored.
     * @return          the expressions as an array of Strings.
    private static String[] readLinesFrom(File calcMe) throws FileNotFoundException {
        List<String> lines = new ArrayList<String>();
        Scanner readIt = new Scanner(calcMe);
        while(readIt.hasNextLine()) {
            String line = readIt.nextLine();
            line = line.replace(" ", ""); // remove all white spaces
            lines.add(line);
        return lines.toArray(new String[]{});
     * @param param     one parameter needed: the file containing the expressions
    public static void main(String[] param) throws FileNotFoundException {
        if(param.length != 1) {
            System.out.println("usage: java KinseyAnthony4 FILENAME");
            System.exit(666);
        String[] expressions = readLinesFrom(new File(param[0]));
        for(String exp: expressions) {
            System.out.println("\nLINE = "+exp);
            IntLinkedStack stack = new IntLinkedStack();
            for(char ch: exp.toCharArray()) {
                if(ch >= '0' && ch <= '9') {
                    int digit = Character.getNumericValue(ch);
                    System.out.println("push: "+digit);
                    stack.push(digit);
                } else {
                    int b = stack.pop();
                    int a = stack.pop();
                    System.out.println("pop: "+a);
                    System.out.println("pop: "+b);
                    System.out.println("calculating: "+a+" "+ch+" "+b);
                    int temp = evaluate(a, ch, b);
                    System.out.println("push: "+temp);
                    stack.push(temp);
            int result = stack.pop();
            System.out.println("***The final result is "+result+"***");
}Now as to your problem: you see that the pop() method throws an exception? You can wrap the necessary lines of code between *try { ... } catch(...) { ... }* statements to catch the exception when an expression in malformed. I hope that makes a bit sense to you, if not, post back.
Good luck.