Mejorar el código de Java: demasiados si es

Question

Tengo varios casos y solo estoy usando bloques simples if ... if else.

¿Cómo puedo reducir el número de declaraciones if en este código?

Quizás podría usar una tabla de búsqueda, pero no estoy seguro de cómo implementarla en Java.

private int transition(char current, int state) 
{ 
    if(state == 0) 
    { 
     if(current == 'b') 
     { 
      return 1; 
     } 
     else 
      return 0; 
    } 
    if(state == 1) 
    { 
     if(current == 'a') 
     { 
      return 2; 
     } 
     else 
      return 0; 
    } 
    if(state == 2) 
    { 
     if(current == 's') 
     { 
      return 3; 
     } 
     else 
      return 0; 
    } 
    if(state == 3) 
    { 
     if(current == 'e') 
     { 
      return 3; 
     } 
     if(current == 'b') 
     { 
      return 4; 
     } 
     else 
      return 0; 
    } 
    if(state == 4) 
    { 
     if(current == 'a') 
     { 
      return 5; 
     } 
     else 
      return 0; 
    } 
    if(state == 5) 
    { 
     if(current == 'l') 
     { 
      return 6; 
     } 
     else 
      return 0; 
    } 
    else 
     return 0; 
} 

Answer 1

Lo que estás tratando de hacer se parece mucho a una máquina de estados finitos, y estos generalmente se implementan con la ayuda de una tabla de transición. Una vez que configura la tabla, simplemente se trata de indexar la posición en la que desea obtener el valor de retorno. Suponiendo que los valores de retorno son todos menores que 256, puede usar una matriz de bytes 2D:

byte table[][] = new byte[NUM_STATES][NUM_CHARACTERS]; 
// Populate the non-zero entries of the table 
table[0]['b'] = 1; 
table[1]['a'] = 2; 
// etc... 

private int transition(char current, int state) { 
    return table[state][current]; 
} 

Answer 2

me cambio declaración sería mejor aquí:

private int transition(char current, int state) 
{ 
    switch(state) 
    { 
     case 0: 
      return current == 'b' ? 1 : 0; 
     case 1: 
      return current == 'a' ? 2 : 0; 
     case 2: 
      return current == 's' ? 3 : 0; 
     case 3: 
      return current == 'e' ? 3 : (current == 'b' ? 4 : 0); 
     case 4: 
      return current == 'a' ? 5 : 0; 
     case 5: 
      return current == 'l' ? 6 : 0; 
     default: 
      return 0; 
    } 
} 

Y una nota, hay solamente 5 si los estados financieros haya comprobar números enteros puros, esto no es exactamente una sobrecarga.

Answer 3

consideran Interfaces + enumeraciones:

interface State<T> 
{ 
    public void State<T> step(T input); 
} 

enum MyState implements State<Character> { 
    STATE0(0) { @Override public void MyState step(Character c) { return c == 'b' ? STATE1 : STATE0; }}, 
    STATE1(1) { @Override public void MyState step(Character c) { return c == 'a' ? STATE2 : STATE0; }}, 

    /* rest of states here */ 

    final private int value; 
    MyState(int value) { this.value = value; } 
    public int getValue() { return this.value; } 
} 

class SomeClass 
{ 
    public MyState currentState = STATE0; 

    public void step(char input) 
    { 
     this.currentState = this.currentState.step(input); 
    } 
} 

Answer 4

Uso switch declaración para la cadena de if exterior:

switch (state) { 
    case 0: <code> ; break; 
    case 1: <code> ; break; 
    case 2: <code> ; break; 
    <etc> 
    default: return 0; break; 
} 

Answer 5

Bueno, se puede utilizar fácilmente hash. Simple y limpio.

// declare hashtable 
    Map<String, Integer> map = new HashMap<String, Integer>(); 
    map.put("0-b", 1); 
    map.put("1-a", 2); 
    map.put("2-s", 3); 
    ... 

    // get result 
    Integer result = map.get(state + "-" + current); 
    // change null (nothing found) to zero 
    return result == null ? 0 : result; 

Answer 6

Parece que necesita una mejor abstracción para una máquina de estados finitos. Piense en una clase que encapsule lo que desea de una mejor manera para que pueda extenderla por configuración en lugar de modificar el código.

Answer 7

Si este código está a punto de expandirse con el tiempo, ¿por qué no utilizar una máquina de estados? Cada estado devolverá el próximo estado en función del personaje que reciba. Tal vez es un exceso para este código, pero será mucho más fácil de mantener, expanda & de lectura.