Infix Expression Evaluator

 

1. /**
2.  * filename: InfixEvaluator.java
3.  * package:  infix
4.  * author:   Li Ma
5.  * email:    [email protected]
6.  * date:     Oct 3, 2008
7.  * description: this class evaluates infix by converting infix to postfix
8.  */
9. package  infix;
11. import  java.util.*;
13. public   class  InfixEvaluator {
15.          /** the stack stores operators */
16.          private  Stack<Character> operatorStack;
17.         
18.          /** the stack stores operands */
19.          private  Stack<Integer> operandStack;
20.         
21.          /** each operator(char) has a integer value of priority */
22.          private   static   final  Map<Character, Integer> OPERATORS;
23.         
24.          /** postfix exp converted from infix exp */
25.          private  StringBuilder postfix;
26.         
27.          /** the infix exp */
28.          private  String infix;
29.         
30.          static  {
31.                  // initialize the static field
32.                 OPERATORS =  new  HashMap<Character, Integer>();
33.                 OPERATORS.put( '+' ,  1 );
34.                 OPERATORS.put( '-' ,  1 );
35.                 OPERATORS.put( '*' ,  2 );
36.                 OPERATORS.put( '/' ,  2 );
37.         }
38.         
39.          /**
40.          * description: the default constructor
41.          */
42.          public  InfixEvaluator() {
43.                  // TODO Auto-generated constructor stub
44.                 operatorStack =  new  Stack<Character>();
45.                 operandStack =  new  Stack<Integer>();
46.                 
47.                 infix =  null ;
48.                 postfix =  new  StringBuilder();
49.         }
51.          /**
52.          * description: the constructor with fields
53.          * @param infixStr - the infix string
54.          */
55.          public  InfixEvaluator(String infixStr) {
56.                  this ();
57.                  this .infix = infixStr;
58.         }
60.          /**
61.          * description: convert a string from infix to postfix
62.          * @throws SyntaxErrorException
63.          */
64.          private   void  convertInfixToPostfix()  throws  SyntaxErrorException {
65.                 StringTokenizer infixTokens =  new  StringTokenizer(infix);
66.                  try  {
67.                          while (infixTokens.hasMoreTokens()) {
68.                                 String next = infixTokens.nextToken();
69.                                  char  firstChar = next.charAt( 0 );
70.                                  // determine whether it is operand
71.                                  if (Character.isJavaIdentifierStart(firstChar)
72.                                                 || Character.isDigit(firstChar)) {
73.                                         postfix.append(next);
74.                                         postfix.append( " " );
75.                                 }  else   if (isOperator(firstChar)) {
76.                                          // it is an operator
77.                                         processOperator(firstChar);
78.                                 }  else  {
79.                                          throw   new  SyntaxErrorException( "Unexpected Character Encountered: "  + firstChar);
80.                                 }
81.                         }
82.                         
83.                          // pop any remaining operators and append them to postfix
84.                          while (!operatorStack.empty()) {
85.                                 Character op = operatorStack.pop();
86.                                 postfix.append(op);
87.                                 postfix.append( " " );
88.                         }
89.                 }  catch (EmptyStackException e) {
90.                          throw   new  SyntaxErrorException( "Syntax error: the stack is empty" );
91.                 }
92.         }
93.         
94.          /**
95.          * description: process operators, let them push or add to the postfix
96.          * @param op - the character of the operator
97.          */
98.          private   void  processOperator( char  op) {
99.                  if (operatorStack.empty()) {
100.                         operatorStack.push( new  Character(op));
101.                 }  else  {
102.                          // peek the operator stack and let topOp be top
103.                          char  topOp = operatorStack.peek().charValue();
104.                          if (OPERATORS.get(op) > OPERATORS.get(topOp)) {
105.                                 operatorStack.push( new  Character(op));
106.                         }  else  {
107.                                  // pop all stacked operators with equal or higher priority than op
108.                                  while (!operatorStack.empty()
109.                                                 && OPERATORS.get(op) <= OPERATORS.get(topOp)) {
110.                                         operatorStack.pop();
111.                                         postfix.append(topOp);
112.                                         postfix.append( " " );
113.                                          if (!operatorStack.empty()) {
114.                                                 topOp = operatorStack.peek().charValue();
115.                                         }
116.                                 }
117.                                 operatorStack.push( new  Character(op));
118.                         }
119.                 }
120.         }
121.         
122.          /**
123.          * description: determine whether the character is an operator
124.          * @param ch - the character to be tested
125.          * @return      true if ch is an operator
126.          */
127.          private   boolean  isOperator( char  ch) {
128.                  return  OPERATORS.containsKey(ch);
129.         }
130.         
131.          /**
132.          * description: evaluate the current operation, poping the two operands off 
133.          * the operand stack and applying the operator.
134.          * @param op - a character representing the operator
135.          * @return the result of applying the operator
136.          */
137.          private   int  evalOp( char  op) {
138.                  // pop the two operands off the stack
139.                  int  rhs = operandStack.pop();
140.                  int  lhs = operandStack.pop();
141.                  int  result =  0 ;
142.                 
143.                  // evaluate the operator
144.                  switch (op) {
145.                  case   '+' :
146.                         result = lhs + rhs;
147.                          break ;
148.                  case   '-' :
149.                         result = lhs - rhs;
150.                          break ;
151.                  case   '*' :
152.                         result = lhs * rhs;
153.                          break ;
154.                  case   '/' :
155.                         result = lhs / rhs;
156.                          break ;
157.                 }
158.                  return  result;
159.         }
160.         
161.          /**
162.          * description: evaluate the whole infix expression
163.          * @return      the value of the infix expression
164.          * @throws SyntaxErrorException
165.          */
166.          public   int  eval()  throws  SyntaxErrorException {
167.                  // translate the infix to postfix
168.                  this .convertInfixToPostfix();
169.                 
170.                  // process each token
171.                 StringTokenizer tokens =  new  StringTokenizer( this .postfix.toString());
172.                  try  {
173.                          while (tokens.hasMoreTokens()) {
174.                                 String next = tokens.nextToken();
175.                                 
176.                                  if (Character.isDigit(next.charAt( 0 ))) {
177.                                          int  value = Integer.parseInt(next);
178.                                         
179.                                          // push value onto operand stack
180.                                         operandStack.push(value);
181.                                 }  else   if (isOperator(next.charAt( 0 ))) {
182.                                          // it is an operator
183.                                          // evaluate the operator
184.                                          int  result = evalOp(next.charAt( 0 ));
185.                                         operandStack.push(result);
186.                                 }  else  {
187.                                          throw   new  SyntaxErrorException( "Invalid character encountered" );
188.                                 }
189.                         }
190.                         
191.                          // no more tokens, pop result from operand stack
192.                          int  answer = operandStack.pop();
193.                          if (operandStack.empty()) {
194.                                  return  answer;
195.                         }  else  {
196.                                  // indicate syntax error
197.                                  throw   new  SyntaxErrorException( "Stack should be empty" );
198.                         }
199.                 }  catch (EmptyStackException e) {
200.                          throw   new  SyntaxErrorException( "the stack is empty" );
201.                 }
202.         }
204. }
207. /**
208.  * filename: SyntaxErrorException.java
209.  * package:  infix
210.  * author:   Li Ma
211.  * email:    [email protected]
212.  * date:     Oct 3, 2008
213.  * description: this exception shows a syntax error.
214.  */
215. package  infix;
217. public   class  SyntaxErrorException  extends  Exception {
219.          private   static   final   long  serialVersionUID = 1L;
221.          public  SyntaxErrorException( final  String message) {
222.                  super (message);
223.         }
224. }