How to Evaluate Math Expression Given in String Form in Java? - Coding

Evaluating a mathematical expression given in string form is a common task in Java programming, often encountered in applications involving mathematical computations or user input processing.

One approach involves using the ScriptEngine class from the javax.script package, which allows for the dynamic execution of scripts, including mathematical expressions written in languages like JavaScript.
Another approach involves the Stack data structure using which we can evaluate string mathematical expressions.

Example of Evaluate String Expressions:

Example 1: Input String: “10-4*5”
Output: -10

Example 2: Input String: “3.5 + 2.8 * ( 4 – 1.2 ) / 2”
Output: 7.42

Program to Evaluate Math Expression Given in String Form in Java

There are certain methods to convert and evaluate a math expression given in string form in Java as mentioned below:

Using ScriptEngineManager Class
Using Stack or logical method

1. Using ScriptEngineManager Class

The Nashorn JavaScript script engine, its APIs, and its tool are deprecated in Java 11. Future iterations of Java will eliminate them. JDK 8 was the most current version to incorporate the Nashorn JavaScript engine.

Java

import javax.script.ScriptEngine; 
import javax.script.ScriptEngineManager; 
import javax.script.ScriptException; 
import java.util.*; 
  
public class GFG { 
    public static void main(String[] args) 
        throws ScriptException 
    { 
       // Create a ScriptEngineManager to manage script engines 
        ScriptEngineManager manager = new ScriptEngineManager(); 
        ScriptEngine engine 
            = manager.getEngineByName("JavaScript");   // Retrieve a JavaScript engine from the manager 
        String str = "10-4*5";    // Define a mathematical expression to evaluate 
        System.out.println(engine.eval(str)); 
    } 
}

Output:

Below is the output of the program in console:

Console output

2. Using Stack or logical method

Java

import java.util.*; 
import java.util.Stack; 
  
public class Main { 
  
    // Function to evaluate a mathematical expression given 
    // in string form 
    public static double
    evaluateExpression(String expression) 
    { 
        char[] tokens = expression.toCharArray(); 
  
        // Stacks to store operands and operators 
        Stack<Double> values = new Stack<>(); 
        Stack<Character> operators = new Stack<>(); 
  
        // Iterate through each character in the expression 
        for (int i = 0; i < tokens.length; i++) { 
            if (tokens[i] == ' ') 
                continue; 
  
            // If the character is a digit or a decimal 
            // point, parse the number 
            if ((tokens[i] >= '0' && tokens[i] <= '9') 
                || tokens[i] == '.') { 
                StringBuilder sb = new StringBuilder(); 
                // Continue collecting digits and the 
                // decimal point to form a number 
                while (i < tokens.length 
                       && (Character.isDigit(tokens[i]) 
                           || tokens[i] == '.')) { 
                    sb.append(tokens[i]); 
                    i++; 
                } 
                // Parse the collected number and push it to 
                // the values stack 
                values.push( 
                    Double.parseDouble(sb.toString())); 
                i--; // Decrement i to account for the extra 
                     // increment in the loop 
            } 
            else if (tokens[i] == '(') { 
                // If the character is '(', push it to the 
                // operators stack 
                operators.push(tokens[i]); 
            } 
            else if (tokens[i] == ')') { 
                // If the character is ')', pop and apply 
                // operators until '(' is encountered 
                while (operators.peek() != '(') { 
                    values.push(applyOperator( 
                        operators.pop(), values.pop(), 
                        values.pop())); 
                } 
                operators.pop(); // Pop the '(' 
            } 
            else if (tokens[i] == '+' || tokens[i] == '-'
                     || tokens[i] == '*'
                     || tokens[i] == '/') { 
                // If the character is an operator, pop and 
                // apply operators with higher precedence 
                while (!operators.isEmpty() 
                       && hasPrecedence(tokens[i], 
                                        operators.peek())) { 
                    values.push(applyOperator( 
                        operators.pop(), values.pop(), 
                        values.pop())); 
                } 
                // Push the current operator to the 
                // operators stack 
                operators.push(tokens[i]); 
            } 
        } 
  
        // Process any remaining operators in the stack 
        while (!operators.isEmpty()) { 
            values.push(applyOperator(operators.pop(), 
                                      values.pop(), 
                                      values.pop())); 
        } 
  
        // The result is the only remaining element in the 
        // values stack 
        return values.pop(); 
    } 
  
    // Function to check if operator1 has higher precedence 
    // than operator2 
    private static boolean hasPrecedence(char operator1, 
                                         char operator2) 
    { 
        if (operator2 == '(' || operator2 == ')') 
            return false; 
        return (operator1 != '*' && operator1 != '/') 
            || (operator2 != '+' && operator2 != '-'); 
    } 
  
    // Function to apply the operator to two operands 
    private static double applyOperator(char operator, 
                                        double b, double a) 
    { 
        switch (operator) { 
        case '+': 
            return a + b; 
        case '-': 
            return a - b; 
        case '*': 
            return a * b; 
        case '/': 
            if (b == 0) 
                throw new ArithmeticException( 
                    "Cannot divide by zero"); 
            return a / b; 
        } 
        return 0; 
    } 
  
    // Driver Code 
    public static void main(String[] args) 
    { 
        String exp = "3.5 + 2.8 * ( 4 - 1.2 ) / 2"; 
        double result = evaluateExpression(exp); 
        System.out.println("Result: " + result); 
    } 
}

Output

Result: 7.42

Illustration:

Java provides multiple methods for evaluating mathematical expressions given in string form.
The straightforward approach involves utilizing the ScriptEngine class from the javax.script package, leveraging its capability to dynamically evaluate expressions, particularly those in JavaScript.
Otherwise we can implement it using stack data structure.

Reffered: https://www.geeksforgeeks.org

Java

Related
How to Split an ArrayList in Multiple Small ArrayLists?
How to Iterate Over a HashSet Without an Iterator in Java?
How to Create a HashSet With a Predefined Capacity in Java?
Validating IPv4 String in Java
How to Shuffle Characters in a String in Java?

Type:	Geek
Category:	Coding
Sub Category:	Tutorial
Uploaded by:	Admin
Views:	13