Question: Requirements You will be provided with an almost complete version of the Evaluator class (Evaluator.java). You should program the utility classes it uses - Operand
Requirements
You will be provided with an almost complete version of the Evaluator class (Evaluator.java). You should program the utility classes it uses - Operand and Operator - and then follow the suggestions in the code to complete the implementation of the Evaluator class. The Evaluator implements a single public method, eval, that takes a single String parameter that represents an infix mathematical expression, parses and evaluates the expression, and returns the integer result. An example expression is 2 + 3 * 4, which would be evaluated to 14.
| The expressions are composed of integer operands and operators drawn from the set +, -, *, /, ^, (, and ). These operators have the following precedence (# and ! will be discussed shortly, and they are extra credit). Operator | Priority |
| +, - | 1 |
| *, / | 2 |
| ^ | 3 |
*********************************EVALUATOR.JAVA****************************************
import java.util.*;
public class Evaluator { private Stack operandStack; private Stack operatorStack;
private StringTokenizer tokenizer; private static final String DELIMITERS = "+-*^/ ";
public Evaluator() { operandStack = new Stack<>(); operatorStack = new Stack<>(); }
public int eval( String expression ) { String token;
// The 3rd argument is true to indicate that the delimiters should be used // as tokens, too. But, we'll need to remember to filter out spaces. this.tokenizer = new StringTokenizer( expression, DELIMITERS, true );
// initialize operator stack - necessary with operator priority schema // the priority of any operator in the operator stack other than // the usual mathematical operators - "+-*/" - should be less than the priority // of the usual operators
while ( this.tokenizer.hasMoreTokens() ) { // filter out spaces if ( !( token = this.tokenizer.nextToken() ).equals( " " )) { // check if token is an operand if ( Operand.check( token )) { operandStack.push( new Operand( token )); } else { if ( ! Operator.check( token )) { System.out.println( "*****invalid token******" ); System.exit( 1 ); }
// ( The Operator class should contain an instance of a HashMap, // and values will be instances of the Operators. See Operator class // skeleton for an example. ) Operator newOperator = new Operator( token );
while ( operatorStack.peek().priority() >= newOperator.priority() ) { // note that when we eval the expression 1 - 2 we will // push the 1 then the 2 and then do the subtraction operation // This means that the first number to be popped is the // second operand, not the first operand - see the following code Operator oldOpr = operatorStack.pop(); Operand op2 = operandStack.pop(); Operand op1 = operandStack.pop(); operandStack.push( oldOpr.execute( op1, op2 )); }
operatorStack.push( newOperator ); } } }
// Control gets here when we've picked up all of the tokens; you must add // code to complete the evaluation - consider how the code given here // will evaluate the expression 1+2*3 // When we have no more tokens to scan, the operand stack will contain 1 2 // and the operator stack will have + * with 2 and * on the top; // In order to complete the evaluation we must empty the stacks (except // the init operator on the operator stack); that is, we should keep // evaluating the operator stack until it only contains the init operator; // Suggestion: create a method that takes an operator as argument and // then executes the while loop; also, move the stacks out of the main // method return 0; } }
*********************************OPERAND.JAVA****************************************
public class Operand {
public Operand( String token ) {
}
public Operand( int value ) {
}
public int getValue() {
}
public static boolean check( String token ) {
} }
*********************************OPERATOR.JAVA****************************************
public abstract class Operator { // The Operator class should contain an instance of a HashMap // This map will use keys as the tokens we're interested in, // and values will be instances of the Operators.
public abstract int priority(); public abstract Operand execute( Operand op1, Operand op2 );
public static boolean check( String token ) {
} }
Step by Step Solution
There are 3 Steps involved in it
Get step-by-step solutions from verified subject matter experts
