java write a program to evaluate the postfix expression the

java write a program to evaluate the postfix expression

the program should ask users for input and show the postfix epression and then the result.

and to have a try and catch exception since we have an empty stack

Solution

Postfix.java

import java.util.Scanner;

public class Postfix
{
    /**
    * Reads and evaluates multiple postfix expressions.
    */
    public static void main (String[] args)
    {
        String expression, again;
        int result;
      
        try
        {
            Scanner in = new Scanner(System.in);
            do
            {
                PostfixEvaluator evaluator = new PostfixEvaluator();
                System.out.println (\"Enter a valid postfix expression: \");
                expression = in.nextLine();
                result = evaluator.evaluate (expression);
                System.out.println();
                System.out.println (\"That expression equals \" + result);
                System.out.print (\"Evaluate another expression [Y/N]? \");
                again = in.nextLine();
                System.out.println();
            }
            while (again.equalsIgnoreCase(\"y\"));
        }
        catch (Exception IOException)
        {
            System.out.println(\"Input exception reported\");
        }
    }
}

PostfixEvaluator.java

//import datastructures.ArrayStack;
import java.util.StringTokenizer;

public class PostfixEvaluator
{
    /** constant for addition symbol */
    private final char ADD = \'+\';
  
    /** constant for subtraction symbol */
    private final char SUBTRACT = \'-\';

    /** constant for multiplication symbol */
    private final char MULTIPLY = \'*\';

    /** constant for division symbol */
    private final char DIVIDE = \'/\';

    /** the stack */
    private ArrayStack<Integer> stack;

    /**
    * Sets up this evaluator by creating a new stack.
    */
    public PostfixEvaluator()
    {
        stack = new ArrayStack<Integer>();
    }

    /**
    * Evaluates the specified postfix expression. If an operand is
    * encountered, it is pushed onto the stack. If an operator is
    * encountered, two operands are popped, the operation is
    * evaluated, and the result is pushed onto the stack.
    * //param expr String representation of a postfix expression
    * //return int value of the given expression
    */
    public int evaluate (String expr)
    {
        int op1, op2, result = 0;
        String token;
        StringTokenizer tokenizer = new StringTokenizer (expr);
      
        while (tokenizer.hasMoreTokens())
        {
            token = tokenizer.nextToken();
            if (isOperator(token))
            {
                op2 = (stack.pop()).intValue();
                op1 = (stack.pop()).intValue();
                result = evalSingleOp (token.charAt(0), op1, op2);
                stack.push (new Integer(result));
            }
            else
                stack.push (new Integer(Integer.parseInt(token)));
        }
      
        return result;
    }

    /**
    * Determines if the specified token is an operator.
    * //param token String representing a single token
    * //return boolean true if token is operator
    */
    private boolean isOperator (String token)
    {
        return ( token.equals(\"+\") || token.equals(\"-\") ||
        token.equals(\"*\") || token.equals(\"/\") );
    }
  
    /**
    * Performs integer evaluation on a single expression consisting of
    * the specified operator and operands.
    * //param operation operation to be performed
    * //param op1 the first operand
    * //param op2 the second operand
    * //return int value of the expression
    */
    private int evalSingleOp (char operation, int op1, int op2)
    {
        int result = 0;
        switch (operation)
        {
            case ADD:
                result = op1 + op2;
                break;
            case SUBTRACT:
                result = op1 - op2;
                break;
            case MULTIPLY:
                result = op1 * op2;
                break;
            case DIVIDE:
                result = op1 / op2;
        }
        return result;
    }
}

ArrayStack.java

import java.util.Arrays;

public class ArrayStack<T> implements StackADT<T> {

    private final static int DEFAULT_CAPACITY = 100;

    private int top;
    private T[] stack;

    /**
     * Creates an empty stack using the default capacity.
     */
    public ArrayStack() {
        this(DEFAULT_CAPACITY);
    }

    /**
     * Creates an empty stack using the specified capacity.
     *
     * //param initialCapacity the initial size of the array
     */
    public ArrayStack(int initialCapacity) {
        top = 0;
        stack = (T[]) (new Object[initialCapacity]);
    }

    /**
     * Adds the specified element to the top of this stack, expanding the
     * capacity of the array if necessary.
     *
     * //param element generic element to be pushed onto stack
     */
    public void push(T element) {
        if (size() == stack.length) {
            expandCapacity();
        }

        stack[top] = element;
        top++;
    }

    /**
     * Creates a new array to store the contents of this stack with twice the
     * capacity of the old one.
     */
    private void expandCapacity() {
        stack = Arrays.copyOf(stack, stack.length * 2);
    }

    /**
     * Removes the element at the top of this stack and returns a reference to
     * it.
     *
     * //return element removed from top of stack
     * //throws EmptyCollectionException if stack is empty
     */
    public T pop() throws EmptyCollectionException {
        if (isEmpty()) {
            throw new EmptyCollectionException(\"stack\");
        }

        top--;
        T result = stack[top];
        stack[top] = null;

        return result;
    }

    /**
     * Returns a reference to the element at the top of this stack. The element
     * is not removed from the stack.
     *
     * //return element on top of stack
     * //throws EmptyCollectionException if stack is empty
     */
    public T peek() throws EmptyCollectionException {
        if (isEmpty()) {
            throw new EmptyCollectionException(\"stack\");
        }

        return stack[top - 1];
    }

    /**
     * Returns true if this stack is empty and false otherwise.
     *
     * //return true if this stack is empty
     */
    public boolean isEmpty() {
        return (top == 0);
    }

    /**
     * Returns the number of elements in this stack.
     *
     * //return the number of elements in the stack
     */
    public int size() {
        return top;
    }

    /**
     * Returns a string representation of this stack.
     *
     * //return a string representation of the stack
     */
    public String toString() {
        String result = \"\";

        for (int scan = 0; scan < top; scan++) {
            result = result + stack[scan] + \"\ \";
        }

        return result;
    }
}

StackADT.java

public interface StackADT<T>
{
    /**
     * Adds the specified element to the top of this stack.
     * //param element element to be pushed onto the stack
     */
    public void push(T element);

    /**
     * Removes and returns the top element from this stack.
     * //return the element removed from the stack
     */
    public T pop();

    /**
     * Returns without removing the top element of this stack.
     * //return the element on top of the stack
     */
    public T peek();

    /**
     * Returns true if this stack contains no elements.
     * //return true if the stack is empty
     */
    public boolean isEmpty();

    /**
     * Returns the number of elements in this stack.
     * //return the number of elements in the stack
     */
    public int size();

    /**
     * Returns a string representation of this stack.
     * //return a string representation of the stack
     */
    public String toString();
}

EmptyCollectionException.java

public class EmptyCollectionException extends RuntimeException{
    public EmptyCollectionException(String collection)
    {
        super(\"The \" + collection + \" is empty.\");
    }
}