Detecting type of operator stored as string in java [duplicate]

Answer 1

First Split the string and store the operator in the Character variable. You can use split() to split a String and assign it to a String array. Access operator using the array index and assign it to a Character variable.

Now You can use Map<Character,Object> where you can store character and object to calculate in single structure and access later with character only without any if-else or switch.

Map<Character,Object> map = new HashMap<>();
map.put('+', plusObject);
map.put('-', minusObject);
map.put('*', multiplyObject);
map.put('/', divideObject);

To get the object type of operator, you can use map.get(character) it will return the object according to the character and null otherwise.

Update: Create four classes and a object for each class namely plusObject, minusObject, multiplyObject,divideObject. These are the objects that you add to HashMap initially. Have a evaluate() function in each class. Now with the returned object, call the evaluate() method which will make call to respective class. You need not check the Object type using any conditional statements.

Answer 2

You can convert the postfix expression into infix mathematical expression and execute it using expression evaluator in Java or javascript(not preferred). As you recommend java, following link will help you:

evaluating-a-math-expression-given-in-string-form

java-parse-a-mathematical-expression-given-as-a-string-and-return-a-number

Answer from above two links:

You can pass it to a BeanShell bsh.Interpreter, something like this:

Interpreter interpreter = new Interpreter(); 
interpreter.eval("result = 5+4*(7-15)");
System.out.println(interpreter.get("result"));

Let us know if your issue gets resolved.

Answer 3

Another solution from J. Selva's response:

Improvements

1. single class
2. static block
3. better abstraction

import java.util.HashMap; import java.util.Map;

/**
 * Created by SEA-HAWK on 23/8/15.
 */
public abstract class Expr {
    public static Map<String,Object> op;
    static{
        op=new HashMap<>();
        op.put("+", new Expr() {
            @Override
            public int evaluate(int a, int b) {
                return a + b;
            }
        });
        op.put("-", new Expr() {
            @Override
            public int evaluate(int a, int b) {
                return a - b;
            }
        });
        op.put("*", new Expr() {
            @Override
            public int evaluate(int a, int b) {
                return a * b;
            }
        });

        op.put("/", new Expr() {
            @Override
            public int evaluate(int a, int b) {
                return a / b; // decimal point loss
            }
        });
    }
    abstract public int evaluate(int a, int b);
    public static int exprEval(String expr){
        String a[]=expr.split(",");
        a[2]=a[2].replaceAll("\"","");
        return ((Expr)op.get(a[2])).evaluate(Integer.parseInt(a[0]),Integer.parseInt(a[1]));
    }
}

Main function:

public static void main(String[] args) {
    String x="20,10,\"*\"";
    System.out.println(x+"="+Expr.exprEval(x));
     x="20,10,\"+\"";
    System.out.println(x+"="+Expr.exprEval(x));
     x="20,10,\"-\"";
    System.out.println(x+"="+Expr.exprEval(x));
    x="20,10,\"/\"";
    System.out.println(x+"="+Expr.exprEval(x));
}

Output:

20,10,"*"=200
20,10,"+"=30
20,10,"-"=10
20,10,"/"=2

Note: change datatype for float/decimal value computation.