Program must use stacks in order to evaluate integer expressions. Your program need only implement the following binary operators:

+ ... addition
- ... subtraction
* ... multiplication
/ ... integer division
< ... minimum (e.g. 3 < 2 yields 2)
> ... maximum (e.g. 3 > 2 yields 3)

To keep the assignment somewhat more manageable you may assume that all input integers are unsigned single decimal digits (0-9). However, your evaluation may result in larger and/or negative integers.

The evaluation of expressions must recognize the standard precedence:

< and > have the highest precedence
* and / have the middle precedence
+ and - have lowest precedence

Expressions must also permit the usual use of parentheses (...) to override precedence.

Below are several examples of proper expressions:

1+2*3>4

(24-7)/2+6<3*(31-299)

2*3*4*5*6

10>9*8+7+2

Your program must read input expressions from a text file and allow the user to select which text file to process using a JFileChooser. You may assume that each line of the text file is a separate integer expression and that there are no blanks or other invalid characters in the file.

For each input expression your program should output (using System.out.println) the input line followed by "==" then followed by the numeric value of the resulting expressions evaluation.

You must implement a bounded generic Stack class. Represent your Stack using an array to hold the stack content. (An array with a maximum of one hundred cells will be more than adequate.)

The standard algorithm for evaluating expressions of this style is to use two stacks - one stack for operators and the other for operands/subexpression values. An expression is processed left to right as follows:

• Each operand encountered is pushed upon the operand stack.

• Each left paren encountered is pushed upon the operator stack.

• Each right paren causes operators to be popped from the operator stack and the associated subexpressions evaluated until a left paren is found in the operator stack. The left paren is then popped.

• Each operator has its precedence compared to the precedence of the operator atop the operator stack. Operators are popped off the operator stack and their corresponding subexpressions evaluated until the top of the operator stack is either a left paren or has a precedence less than the new operator. After evaluating subexpressions, the new operator is pushed onto the operator stack.

• At the end of the expression all operators on the operator stack must be popped and their corresponding subexpressions evaluated. The value of the expression should be the single remaining value atop the operand stack.

When the prior explanations refer to "popping an operator and evaluating the corresponding subexpression" this means that the operand stack should be popped twice, and the two popped operands are evaluated using the popped operator with the resulting value pushed on the operand stack. For example, if the top of the operand stack is a 7 and the second operand in the operand stack is a 3 and the operator is a "-", then all three of these are popped and the result of the subexpression 3-7 (i.e., the value -4) is pushed on the operand stack.