Java Enum handling

Question

J'ai une question Java sur la meilleure méthode pour travailler avec le fichier enum suivant qui m'a été fourni.

public enum Foo{ 

    PLANE(1, "Plane", "plane"), 
    CASTLE(2, "Castle", "castle"), 
    FEILD(3, "Feild", "field"), 
    ROAD(4, "Road", new String[] {"road", "pavement"}); 
} 

Il y a à peu près entrées 100ish des formats ci-dessus

/** 
* Stores a map of the names for fast access. Stores a map of the IDs for fast access. 
*/ 
    private static final Map<Integer,BlockType> ids = new HashMap<Integer,BlockType>(); 

    private static final Map<String,BlockType> lookup = new HashMap<String,BlockType>(); 

    private final int id; 
    private final String name; 
    private final String[] lookupKeys; 

    static { 
     for(Foo type : EnumSet.allOf(Foo.class)) { 
      ids.put(type.id, type); 
      for (String key : type.lookupKeys) { 
       lookup.put(key, type); 
      } 
     } 
    } 


    /** 
* Construct the type. 
* 
* @param id 
* @param name 
*/ 
    Foo(int id, String name, String lookupKey) { 
     this.id = id; 
     this.name = name; 
     this.lookupKeys = new String[]{lookupKey}; 
    } 

    /** 
* Construct the type. 
* 
* @param id 
* @param name 
*/ 
    Foo(int id, String name, String[] lookupKeys) { 
     this.id = id; 
     this.name = name; 
     this.lookupKeys = lookupKeys; 
    } 

    /** 
* Return type from ID. May return null. 
* 
* @param id 
* @return 
*/ 
    public static Foo fromID(int id) { 
     return ids.get(id); 
    } 

    /** 
* Return type from name. May return null. 
* 
* @param name 
* @return 
*/ 
    public static Foo lookup(String name) { 
     return lookup.get(name.toLowerCase()); 
    } 

    /** 
* Get block numeric ID. 
* 
* @return 
*/ 
    public int getID() { 
     return id; 
    } 

    /** 
* Get user-friendly name. 
* 
* @return 
*/ 
    public String getName() { 
     return name; 
    } 

Donc ce que je suis en train de faire avec ce ENUM est la suivante: Un utilisateur émet une commande, par exemple:/rebond 1

Le programme reconnaît bounce comme une commande et cherche l'argument suivant. Puisque 1 suit la commande, il vérifie maintenant que 1 est un identifiant valide # dans l'énumération. Si c'est le cas, il exécute la commande.

Un utilisateur émet une commande pour l'exemple 2 sous la forme suivante:/plan de rebond. Cette fois-ci, il vérifie si la chaîne est un nom de chaîne valide dans l'énumération et si elle est capturée, l'id # lui est associé pour exécuter la commande.

Comment puis-je vérifier pour ces critères que l'ID ou l'un des ID de chaîne existe et toujours retourner l'ID # pour une utilisation ultérieure. Toute aide serait appréciée.

Il convient également de noter que ce fichier enum est son propre fichier de classe indépendant appelé à partir du principal. Merci à tous ceux qui m'ont aidé à me mettre sur la bonne voie, j'ai donné la bonne réponse à Wolfcastle, voici ce que j'ai pu faire pour moi mais je suis toujours ouvert aux critiques sur la logique ou les défauts de performance avec ma méthode.

String s = null; 
     try { 
      s = in.readLine(); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     try { 
      id = Integer.parseInt(s); 
     } catch (NumberFormatException nfe) { 

     } 
     if (BlockType.lookup(s) != null 
       || BlockType.fromID(id) != null) { 
      if (BlockType.lookup(s)!= null) { 
       blockname = BlockType.lookup(s).getName(); 
       blockid = BlockType.lookup(s).getID(); 
      } else { 
       blockname = BlockType.fromID(id).getName(); 
       blockid = BlockType.fromID(id).getID(); 
      } 
     } 

Answer 1

Donc, si je vous comprends bien, le code que vous avez affiché est pas votre code, mais vous devez utiliser le code, et vous vous demandez comment vous pouvez l'utiliser.

String param = getParam(); // get the '1' or 'plane' string from your input 
    BlockType type = null; 
    try { 
     // Check for an integer 
     int id = Integer.parseInt(param); 
     type = BlockType.getFromId(id); 
    } catch(NumberFormatException e) { 
     // Okay, not an integer, check the lookup value 
     type = BlockType.lookup(param); 
    } 

    if(type != null) { 
       int blockid = type.getID(); 
       String blockname = type.getName(); 
       // continue on 
    } else { 
    // else the input parameter was invalid and we can't get a BlockType for it 
    // return some kind of error 
    } 

Answer 2

Dans ce cas, vous pouvez simplement vérifier si la valeur renvoyée est nulle. Ou que voulez-vous vérifier exactement?

Notez également que vous n'avez pas besoin EnumSet:

static { 
    for(Foo type : values()) { 
     ids.put(type.id, type); 
     for (String key : type.lookupKeys) { 
      lookup.put(key, type); 
     } 
    } 
}