Realización operación matemática cuando el operador se almacena en una cadena

Question

tengo 2 enteros:

int first= 10; 
int second = 20; 

y una cadena que representa la operación (una de +, -, /, o *):

String op = "+"; 

¿Cómo puedo obtener el resultado de 10 + 20 en este ejemplo?

Answer 1

No recomiendo esto, pero es divertido. en java6

String op = '+'; 
int first= 10; 
int second = 20; 
ScriptEngineManager scm = new ScriptEngineManager(); 
ScriptEngine jsEngine = scm.getEngineByName("JavaScript"); 
Integer result = (Integer) jsEngine.eval(first+op+second); 

ir con el interruptor, pero recuerde que debe convertir el operador de cadena charla como interruptor no funciona con cadenas todavía.

switch(op.charAt(0)){ 
    case '+': 
     return first + second; 
     break; 
    // and so on.. 

Answer 2

switch (op.charAt(0)) { 
    case '+': return first + second; 
    case '-': return first - second; 
    // ... 
} 

Answer 3

public double doMath(int first, int second, char op){ 

    switch(op){ 
    case '+': 
     return first + second; 
     break; 
    case '-': 
     return first - second; 
     break; 
    case '*': 
     return first * second; 
     break; 
    case '/': 
     return first/second; 
     break; 
    default: 
     return 0; 
    } 
} 

Answer 4

switch(string){ 
} 

(interruptor de cadenas) se permitirá en Java7. Ahora se puede cambiar con carbón

switch(string.charAt(0)){ 
    case '+' : ... 
} 

como se mencionó anteriormente

Answer 5

puede probar el siguiente código. Está orientado a objetos, bastante genérico, y se puede ampliar fácilmente para añadir nuevos operadores, incluidos los operadores con un número diferente de argumentos:

public abstract class Operator { 
    public abstract Integer compute(Integer...values); 
} 

public class Plus extends Operator { 
    public Integer compute(Integer...values) { 
    return values[0] + values[1]; 
    } 
} 

public class Minus extends Operator { 
    public Integer compute(Integer...values) { 
    return values[0] - values[1]; 
    } 
} 

public class Multiply extends Operator { 
    public Integer compute(Integer...values) { 
    return values[0] * values[1]; 
    } 
} 


public class Divide extends Operator { 
    public Integer compute(Integer...values) { 
    return values[0]/values[1]; 
    } 
} 

Map operatorMap = createOperatorMap(); 

public Map createOperatorMap() { 
    Map<String, Operator> map = new HashMap<String, Operator>(); 
    map.put("+", new Plus()); 
    map.put("-", new Minus()); 
    map.put("*", new Multiply()); 
    map.put("/", new Divide()); 
    return map; 
} 

public int compute(int a, int b, String opString) { 
    Operator op = operatorMap.get(opString); 
    if (op == null) 
    throw new IllegalArgumentException("Unknown operator"); 
    return op.compute(a, b); 
}