希望以更清潔/更有效的方式將字符串與int相關聯

Question

我怎樣才能改善這個？

關系是一對一的，並且在[-1,5]上連續，所以我想使用枚舉，但我不確定如何將字符串值與枚舉值進行比較。

如果有更好的方法，請建議。

謝謝！

private int evaluateWord(String sval) {
    if (sval.equals("program"))
        return 1;
    else if (sval.equals("begin"))
        return 2;
    else if (sval.equals("end"))
        return 3;
    else if (sval.equals("int"))
        return 4;
    else if (sval.equals("if"))
        return 5;
    else
        System.exit(0);

Answer 1

您是否考慮過將映射填充到HashMap中一次，然后只查詢映射？

例如，像這樣：

 private static final Map<String,Integer> m_map = new HashMap<String,Integer>();
 static {
     m_map.put( "program", 1 );
     m_map.put( "begin", 2 );
     m_map.put( "end", 3 );
     m_map.put( "int", 4 );
     m_map.put( "if", 5 );
 }

 private int evaluateWord(String sval) {
     Integer value = m_map.get( sval );
     if ( null != value ) {
        return value;
     }
     else {
        System.exit(0);
     }
 }

順便說一句，看起來好像你正在編寫一個解析器。 手動編寫解析器是合理的。 除非你有充分的理由手工編寫，否則另一個需要考慮的選擇是像ANTLR這樣的解析器生成器。

Answer 2

使用枚舉：

enum Word {
  PROGRAM(1,"program"),
  BEGIN(2,"begin"),
  END(3,"end"),
  INT(4,"int"),
  IF(5,"if");

  private final int value;
  private final String representation;

  Word(int value, String representation)
  {
    this.value = value;
    this.representation = representation;
  }

  public int value()
  { return value; }

  private static Map<String, Word> fromRep =
    new HashMap<String, EnumExample2.Word>();

  public static Word fromRepresentation(String rep) {
    if (!validRep(rep)) {
      throw new IllegalArgumentException("No rep: "+rep);
    }

    return fromRep.get(rep);
  }

  public static boolean validRep(String rep)
  { return fromRep.get(rep) != null; }

  static {
    for (Word word : Word.values()) {
      fromRep.put(word.representation, word);
    }
  }
}

那你的邏輯是：

private int evaluateWord(String sval) {
  if (!Word.validRep(sval)) {
    System.exit(0);
  }

  return Word.fromRepresentation(sval).value();
}

Answer 3

哈希映射可以工作：

private static HashMap<String, Integer> lookup = new HashMap<String, Integer>();
static {
    lookup.put("program", 1);
    lookup.put("being", 2);
    lookup.put("end", 3);
    lookup.put("int", 4);
    lookup.put("if", 5);
}

private int evaluateWord(String sval) {
    if ( lookup.containsKey(sval) ) {
        return lookup.get(sval);
    }
    System.exit(0); 
}

Answer 4

這就是地圖的用途;

創建一個HashMap，向地圖添加鍵和值

wordMap.put("program", Integer.valueOf(1));

....

然后，獲得價值

Integer val = wordMap.get(sval);

Answer 5

老實說，我不擔心保持這樣的超高效，但你可以做出改變。 如果您傳遞的單詞是您檢查的最后一個單詞，那么您的程序最終會執行您函數中的所有檢查。 在這種情況下，這不應該是一個問題，但通常你不想用if語句泛濫你的程序，特別是如果你有很多情況。

使用哈希表並只插入對。 這樣，所有的evaluateWord調用都將以分攤的常量時間返回。 :)

祝好運！

Answer 6

為什么你需要（非常主觀）“清潔”的方式？

您可以通過使用哈希查找獲得更高的效率，但是您需要確定它的調用非常有用，以使額外的編碼工作變得有價值。 如果不經常發生的事情（並且，那意味着每秒不到一次），那就不值得做（YAGNI）。

你可能想要做的更好看的代碼（如果這很重要）就是拋棄else位，它們完全是不必要的：

private int evaluateWord(String sval) {
    if (sval.equals("program")) return 1;
    if (sval.equals("begin"))   return 2;
    if (sval.equals("end"))     return 3;
    if (sval.equals("int"))     return 4;
    if (sval.equals("if"))      return 5;
    System.exit(0);
}

Answer 7

受到你的枚舉評論的啟發，我提出以下內容。 這有點hackish，但是：

enum Word
{
    PROGRAM (1), BEGIN (2), END (3), INT (4), IF (5);

    public int value;

    public Word (int value)
    {
        this.value = value;
    }
};

int evaluateWord (String word)
{
    return Word.valueOf(word.toUpperCase( )).value;
}

我喜歡Java enums，因為你可以做這樣的事情。 如果您以后想要（例如）為每個單詞添加唯一的行為，或者維護一長串單詞，這將特別有用。 請注意，它不區分大小寫。

或者，或者：

enum Word
{
    PROGRAM, BEGIN, END, INT, IF;
};

int evaluateWord (String word)
{
    return Word.valueOf(word.toUpperCase( )).ordinal( ) + 1;
}

Answer 8

您可以使用數組或散列映射將枚舉值映射到字符串值。