जावा कोड में सुधार करें:

Question

में बहुत से मामले हैं मेरे पास कई मामले हैं और मैं बस सरल if ... if else ब्लॉक का उपयोग कर रहा हूं।

मैं इस कोड में if कथनों की संख्या को कैसे कम कर सकता हूं?

शायद मैं एक लुकअप टेबल का उपयोग कर सकता हूं, लेकिन मुझे यकीन नहीं है कि जावा में इसे कैसे कार्यान्वित किया जाए।

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

जो आप करने की कोशिश कर रहे हैं वह एक सीमित राज्य मशीन की तरह दिखता है, और इन्हें आमतौर पर एक संक्रमण तालिका की सहायता से लागू किया जाता है। एक बार जब आप टेबल सेट अप कर लेते हैं, तो यह केवल उस स्थिति को अनुक्रमणित करने का मामला है जिसे आप रिटर्न वैल्यू प्राप्त करना चाहते हैं। मान लें कि आपके रिटर्न वैल्यू 256 से कम हैं, आप 2 डी बाइट सरणी का उपयोग कर सकते हैं:

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

मैं स्विच बयान यहाँ सबसे अच्छा होगा:

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; 
    } 
} 

और एक नोट, वहाँ केवल 5 बयान वहाँ शुद्ध intergers पता चल सके कि, यह वास्तव में एक ओवरहेड है।

Answer 3

पर विचार इंटरफेस + enums:

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

उपयोग switch बाहरी if श्रृंखला के लिए बयान:

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

Answer 5

ठीक है, आप आसानी से hash उपयोग कर सकते हैं। सरल और साफ

// 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

ऐसा लगता है कि आपको एक सीमित राज्य मशीन के लिए बेहतर अमूर्तता की आवश्यकता है। एक वर्ग के बारे में सोचें जो आप बेहतर तरीके से चाहते हैं कि आप कोड को संशोधित करने के बजाय कॉन्फ़िगरेशन द्वारा बढ़ा सकते हैं।

Answer 7

यदि यह कोड उस समय विस्तारित होने वाला है, तो राज्य मशीन का उपयोग क्यों न करें? प्रत्येक राज्य अगले राज्य को प्राप्त चरित्र के आधार पर वापस कर देगा। शायद यह इस कोड के लिए एक ओवरकिल है, लेकिन इसे बनाए रखने के लिए बहुत आसान हो जाएगा, & का विस्तार करें।