Il modo più elegante per applicare un operatore trovato come stringa in java?

Question

Potenzialmente stupido: Supponendo che io abbia una stringa contenente un operatore qual è il modo migliore per applicare questo operatore?

Quello che tendo a fare è:

if(n.getString(1).equals("<<")) { 
    result = tmp1 << tmp2; 
} 

per ogni tipologia di operatore che ho. C'è un modo migliore ?

Answer 1

potuto fare qualcosa di simile:

enum Operator { 

BITSHIFT { ... }, ADD { ... }, XOR { ... }, //...etc 

Operator public static which(String s) { //...return the correct one 
} 

public abstract int apply(int a, int b); //...defined explicitly for each enum 

} 

il ritorno quella giusta sarà veramente bello una volta passare dichiarazioni sono andare per String s.

Questa soluzione è simile al seguente in uso (sans Operator. se si utilizza un import statica):

int result = Operator.which(s).apply(a,b); 

ma mi piacerebbe andare con qualcun altro è ampiamente testato e utilizzato parser.

Answer 2

L'utilizzo di un parser effettivo sarebbe probabilmente più robusto, anche se potrebbe essere eccessivo a seconda di quanto sia complesso il problema. JavaCC e ANTLR sono probabilmente i due generatori di parser più popolari nel mondo Java.

Se un generatore di parser è eccessivo (probabilmente perché non si ha/desidera creare una grammatica formale), è possibile utilizzare probabilmente Ragel per implementare un parser personalizzato.

Answer 3

Non è sicuro se si chiamerebbe questo elegante, ma qui è un modo:

interface Operation { 
    int apply(int a, int b); 
} 

Map<String, Operation> operations = new HashMap<String, Operation>() {{ 
    put("+", new Operation() { public int apply(int a, int b) { return a + b; }}); 
    put("-", new Operation() { public int apply(int a, int b) { return a - b; }}); 
    put("*", new Operation() { public int apply(int a, int b) { return a * b; }}); 
    put("<<", new Operation() { public int apply(int a, int b) { return a << b; }}); 
    // some more operations here 
}}; 

allora si potrebbe sostituire la sua dichiarazione con if:

result = operations.get(n.getString(1)).apply(tmp1, tmp2); 

Answer 4

si potrebbe usare un JSR-223 linguaggio interpretativo come BeanShell, farlo eseguire l'operazione e quindi ottenere il risultato.

Answer 5

A meno che non si disponga di un ampio gruppo di operatori o si voglia essere in grado di consentire espressioni più complesse in futuro, no.

Un modo per fare questo (pseudocodice, se Java ha avuto questa sintassi, questa sarebbe una buona opzione anche con un piccolo insieme di operatori):

final Map<String,Function<(X,X), Y>> OPERATORS = { 
    "<<" : (x,y)->{x << y}, 
    "+" : (x,y)->{x + y}, 
    [...] 
}; 

[...] 

result1 = OPERATORS.get(n.getString(1))(tmp1, tmp2); 

si può scrivere questo in Java, ma a causa di mancanza di letterali concettuali sulla mappa e dichiarazioni di classi anonime, è molto più prolisso.

L'altra opzione è, ha pubblicato da Hank Gay, utilizzare un parser/valutatore "reale". Puoi scrivere il tuo o usare qualcosa come commons-jexl. A meno che non vogliate consentire espressioni più complesse (e quindi sarete obbligati a seguire questa strada), questo è davvero eccessivo.

Answer 6

Il modo orientato agli oggetti per farlo sarebbe utilizzare un'enumerazione delle operazioni possibili. In questo modo ogni operazione poteva solo consumare un oggetto in memoria.

public enum Operation { 


    ADD() { 
    public int perform(int a, int b) { 
     return a + b; 
    } 
    }, 
    SUBTRACT() { 
    public int perform(int a, int b) { 
     return a - b; 
    } 
    }, 
    MULTIPLY() { 
    public int perform(int a, int b) { 
     return a * b; 
    } 
    }, 
    DIVIDE() { 
    public int perform(int a, int b) { 
     return a/b; 
    } 
    }; 

    public abstract int perform(int a, int b); 

} 

Per chiamare tale codice, si dovrebbe quindi fare qualcosa di simile:

int result = Operation.ADD(5, 6); 

Poi si potrebbe creare una mappa di stringhe di operazioni, in questo modo:

Map<String, Operation> symbols = new Map<String, Operation>(); 
symbols.put("+", Operation.ADD); 
symbols.put("-", Operation.SUBTRACT); 
symbols.put("/", Operation.DIVIDE); 
symbols.put("*", Operation.MULTIPLY); 
... 

Infine, per utilizzare un tale sistema:

symbols.get(n.getString(1).apply(tmp1, tmp2)); 

Un vantaggio di utilizzare enumerazioni in questo modo è che si ha il lusso di confronto tra le operazioni sui dati, se si sceglie di farlo

Operation operation = symbols.get("*"); 
if (operation != Operation.MULTIPLY) { 
    System.out.println("Foobar as usual, * is not multiply!"); 
} 

Inoltre, si ottiene una posizione centralizzata per tutte le operazioni, l'unico il lato negativo di questo è che il file Operation.java potrebbe diventare grande con un insieme sufficientemente grande di operatori.

L'unico problema che potrebbe esistere a lungo termine è che mentre un tale sistema è utile e di facile lettura e comprensione, in realtà non tiene conto della precedenza. Supponendo che la tua formula sia stata valutata nell'ordine di precedenza, questo problema non ha importanza. Esempi di esprimere la formula nell'ordine di precedenza possono essere trovati in Reverse Polish Notation, Polish Notation, ecc

Dove precedenza che conta è quando si è permesso di esprimere elementi come:

4 + 5 * 2 

dove secondo alla convenzione tipica, il 5 * 2 dovrebbe essere valutato prima del 4 + 5. L'unico modo corretto di gestire la precedenza è quello di formare un albero di valutazione in memoria, o di garantire che tutti gli input maneggiano la precedenza in modo semplice e univoco (Notazione polacca , Notazione polacca inversa, ecc.).

Suppongo che tu sappia dei problemi di precedenza, ma grazie per avermi fatto menzionare per il beneficio di coloro che non hanno ancora dovuto scrivere un tale codice.

Answer 7

Un enum sarebbe pulito per questo tipo di scenario.

public enum Operator 
{ 
    ADD("+") 
    { 
     public int apply(int a, int b) 
     { 
      return a + b; 
     } 
    } 

    SHIFT_LEFT("<<") 
    { 
     public int apply(int a, int b) 
     { 
      return a << b; 
     } 
    } 

    private String opString; 

    private Operator(String op) 
    { 
     opString = op 
    } 

    static public Operator getOperator(String opRep) 
    { 
     for (Operator o:values()) 
     { 
      if (o.opString.equals(opRep)) 
       return o; 
     } 
     throw new IllegalArgumentException("Operation [" + opRep + "] is not valid"); 
    } 

    abstract public int apply(int a, int b); 
} 

Per chiamare

result = Operator.getOperator("<<").apply(456,4); 

Un'altra possibilità sarebbe quella di includere un metodo statico che prende la rappresentazione di stringa dell'operatore nonché operandi e hanno una singola chiamata di metodo, anche se preferisco li separano .

Answer 8

È anche possibile utilizzare il codice hash dell'operatore e inserirlo su un switch sebbene questo non sia molto "elegante" dal punto di vista OOP.

Questo può funzionare se non si sta aggiungendo operatori troppo spesso (che non credo che si sarebbe)

quindi questo dovrebbe essere sufficiente:

String op = "+"; 

switch(op.hashCode()){ 
    case ADD: r = a + b;break; 
    case SUB: r = a - b;break; 
    case TMS: r = a * b;break; 
    case DIV: r = a/b;break; 
    case MOD: r = a % b;break; 
    case SLF: r = a << b;break; 
    case SRG: r = a >> b;break; 
    case AND: r = a & b;break; 
    case OR: r = a | b;break; 
    case XOR: r = a^b;break; 
    default: out.print("Eerr!!!"); break; 
} 

E hanno AND definito come:

private static final int ADD = 0x2b; 

Ecco il codice di esempio in esecuzione completa:

import static java.lang.System.out; 
class Evaluator { 

    private static final int ADD = 0x2b; // + 
    private static final int SUB = 0x2d; // - 
    private static final int TMS = 0x2a; // * 
    private static final int DIV = 0x2f; ///
    private static final int MOD = 0x25; // % 
    private static final int SLF = 0x780; // << 
    private static final int SRG = 0x7c0; // >> 
    private static final int AND = 0x26; // & 
    private static final int OR = 0x7c; // | 
    private static final int XOR = 0x5e; //^

    private int r; 
    private int a; 
    private String op; 
    private int b; 

    private Evaluator(int a, String op, int b) { 
     this.a = a; this.op = op; this.b = b; 
    } 
    private Evaluator eval() { 
     switch(op.hashCode()){ 
      case ADD: r = a + b;break; 
      case SUB: r = a - b;break; 
      case TMS: r = a * b;break; 
      case DIV: r = a/b;break; 
      case MOD: r = a % b;break; 
      case SLF: r = a << b;break; 
      case SRG: r = a >> b;break; 
      case AND: r = a & b;break; 
      case OR: r = a | b;break; 
      case XOR: r = a^b;break; 
      default: out.print("Eerr!!!"); break; 
     } 
     return this; 
    } 

    // For testing: 
    public static int evaluate(int a, String op , int b) { 
     return new Evaluator(a, op, b).eval().r; 
    } 

    public static void main(String [] args) { 
     out.printf(" 1 + 2 = %d%n", evaluate(1 ,"+" , 2)); 
     out.printf(" 1 - 2 = %d%n", evaluate(1 ,"-" , 2)); 
     out.printf(" 1 * 2 = %d%n", evaluate(1 ,"*" , 2)); 
     out.printf(" 1/2 = %d%n", evaluate(1 ,"/" , 2)); 
     out.printf(" 1 %% 2 = %d%n", evaluate(1 ,"%" , 2)); 
     out.printf(" 1 << 2 = %d%n", evaluate(1 ,"<<" , 2)); 
     out.printf(" 1 >> 2 = %d%n", evaluate(1 ,">>" , 2)); 
     out.printf(" 1 & 2 = %d%n", evaluate(1 ,"&" , 2)); 
     out.printf(" 1 | 2 = %d%n", evaluate(1 ,"|" , 2)); 
     out.printf(" 1^2 = %d%n", evaluate(1 ,"^" , 2)); 
    } 
} 

E questo è tutto. Funziona molto velocemente (sono abbastanza sicuro che un enum in ordine)

Da una prospettiva OOP penso che la risposta di Rahul lo farebbe, ma se vuoi fare sul serio con questo dovresti usare un parser come suggerito da Hank Gay .

p.s. Ottenere il codice hash di una stringa è facile:

System.out.println("+".hashCode()); 

realtà ho usato questo:

public class HexHashCode { 
    public static void main(String [] args) { 
     for(String s: args) { 
      System.out.printf("private final int %s = 0x%x; // %s\n",s,s.hashCode(), s); 
     } 
    } 
} 

ed eseguirlo con:

java HexHashCode + - "*"/"<<" ">>" "%" "<" ">" "==" "!=" "&" "|" "^" 

Answer 9

@Robin: in Java è possibile I metodi di astrazione non sono astratti e i tipi di enumerazione non possono essere astratti (perché tutti gli enum sono ereditati da Enum, il che significa che un tipo di enum non può ereditare da un altro dalle regole di ereditarietà di Java)

Inoltre, cosa si può fare è aggiungere un metodo statico chiamato registro:

private static final Map<String, Operator> registered=new HashMap<String,Operator>(); 
private static void register(String op, Operator impl) { 
    registered.put(op, impl); 
} 

e quindi chiamare quel metodo nel costruttore; e utilizzare la ricerca della mappa nel metodo getOperator().

Answer 10

è molto facile da fare in c sharp.

var ops = new Dictionary<string, Func<int, int, int>> { 
    {"+", (a, b) => a + b}, 
    {"-", (a, b) => a - b}, 
    {"*", (a, b) => a * b}, 
    {"/", (a, b) => a/b} 
}; 

prova:

var c = ops["+"](2, 3); 
Console.WriteLine(c); 

stampe 5.