# Java Infix Calculator

## What is Infix expression

Infix notation is the common arithmetic and logical formula notation, in which operators are written infix-style between the operands they act on, as the examples below:

`````` 1+2
3+4``````

A fully parenthesized infix arithmetic expression is an infix arithmetic expression where every operator and its arguments are contained in parentheses, as seen in following:

``````(2+3)
(1+((2+3)∗(4∗5)))``````

## How to Evaluat Infix Expressions Using Generic Stacks

### Steps of Evaluating Infix with Fully Parenthesized [^1]

• Push operands onto the operand stack.
• Push operators onto the operator stack.
• Ignore left parentheses.
• On encountering a right parenthesis, pop an operator, pop the requisite number of operands, and push onto the operand stack the result of applying that operator to those operands.

Steps Simulation

``````((10 + 5) * 3)
3 10 5 + *
-> (
skip
-> (
skip
-> 10
push 10 into operand stack
-> +
push + into operator stack
-> 5
push 10 into operand stack
-> )
pop out +
pop out 5, 10
push 15 into operand stack
-> *
push * into operator stack
-> )
pop out *
pop 15, 3
push 45 into operand stack
`````` ### Implementing Steps

1. Copy the Stack code on Java Stack Implementation page.
2. Save the Stack code as Stack.java
3. Copy the following code and save as InfixEvaluation.java

### Solution

``````/******************************************************************************
*  Compilation:  javac InfixEvaluation.java
*  Execution:    java InfixEvaluation arg
*
*  Java Infix expression Calculator.
*
*  % java InfixEvaluation "((1 + 2) / 2)"
*  1.5
*
******************************************************************************/
class InfixEvaluation {
public static void main(String[] args) {
String[] strArr = args.split("");

System.out.println(calculator(strArr));
}

public static double calculator(String[] strArr) {
Stack<String> operators = new Stack<String>();
Stack<Double> operands = new Stack<Double>();

for(String str : strArr) {
if (str.trim().equals("")) {
continue;
}

switch(str) {
case "(":
break;
case ")":
double right = operands.pop();
double left = operands.pop();
String operator = operators.pop();
double value = 0;
switch(operator) {
case "+":
value = left + right;
break;
case "-":
value = left - right;
break;
case "*":
value = left * right;
break;
case "/":
value = left / right;
break;
default:
break;
}
operands.push(value);
break;
case "+":
case "-":
case "*":
case "/":
operators.push(str);
break;
default:
operands.push(Double.parseDouble(str));
break;
}
}

return operands.pop();
}
}``````

### Related Questions

4.3.14 Write a filter InfixToPostfix that converts an arithmetic expression from infix to postfix.