Enum de Java et si la déclaration, est-il une meilleure façon de le faire?

J'ai un java Enum classe, et à l'exécution, je vais lire une valeur de ligne de commande, et je veux correspondre à cette valeur à une valeur dans mon Enum classe. Shipper est mon Enum Class. Est-il une meilleure façon de le faire, plutôt que de se if et else if ci-dessous? Cette moche.

private List<Shipper> shipperName = new ArrayList<Shipper>();
...
public void init(String s){ 
    if(s.equals("a")){
        shipperName.add(Shipper.A);
    }else if(s.equals("b")){
        shipperName.add(Shipper.B);
    }else if(s.equals("c")){
        shipperName.add(Shipper.C);
    }else if(s.equals("d")){
        shipperName.add(Shipper.D);
    }else if(s.equals("e")){
        shipperName.add(Shipper.E);
    }else{
        System.out.println("Error");
    }
}

Voici mon Shipper.class

public enum Shipper
{
    A("a"),
    B("b"),
    C("c"),
    D("e"),
    F("f")
;

    private String directoryName;

    private Shipper(String directoryName)
    {
         this.directoryName = directoryName;
    }

    public String getDirectoryName()
    {
         return directoryName;
    }
}

(Et si s ne correspond pas à un nom?)
Puis d'erreur sera imprimé.
Ce n'est pas ce que le code dit (et je suis un grand croient en croyant code sur la documentation).
juste mettre à jour le code. Désolé à ce sujet.

OriginalL'auteur Thang Pham | 2011-05-12

enums java

6

Oui ajouter la chaîne dans l'enum du constructeur (à spécifier un constructeur dans l'enum qui prend une Chaîne de caractères) et de créer des énumérations avec une valeur de texte de a, b , c. Etc. Puis de mettre en œuvre une statique de la méthode de fabrique sur l'enum qui prend une chaîne de caractères et renvoie l'enum instance. J'appelle cette méthode textValueOf. L'existant méthode valueOf dans enum ne peut pas être utilisé pour cela. Quelque chose comme ceci:
```
public enum EnumWithValueOf {

    VALUE_1("A"), VALUE_2("B"), VALUE_3("C");

    private  String textValue;

    EnumWithValueOf(String textValue) {
        this.textValue = textValue;
    }

    public static EnumWithValueOf textValueOf(String textValue){

        for(EnumWithValueOf value : values()) {
            if(value.textValue.equals(textValue)) {
                return value;
            }
        }

        throw new IllegalArgumentException("No EnumWithValueOf
                            for value: " + textValue);  
    }   
}
```
C'est la casse et la valeur de texte peut être différent de l'enum nom - parfait si votre base de données de codes ésotériques ou non descriptive, mais vous voulez la meilleure des noms dans le code Java. Code Client, puis faire:
```
EnumWithValueOf enumRepresentation = EnumWithValueOf.textValueOf("a");
```
Pouvez-vous fourni quelques codes?
"Le valueOf méthode enum ne peut pas être utilisé pour cela." Pourquoi?
Parce que vous aurez "L'enum EnumClassName déjà définit la méthode valueOf(String) implicitement"
Il n'était pas clair à partir de la question initiale que la valeur pourrait être différent du nom de l'énumération.
Je vous remercie beaucoup. Ce grand travail.

OriginalL'auteur planetjones
5
```
shipperName.add(Shipper.valueOf(s.toUpperCase()));
```
Si le nom ne correspond pas toujours à l'énumération que vous pouvez faire quelque chose comme ceci
```
public static Shipper getShipper(String directoryName) {
    for(Shipper shipper : Shipper.values()) {
        if(shipper.getDirectoryName().equals(directoryName)) {
            return shipper;
        }
    }
    return null; //Or thrown exception
}
```
Note valueOf() va lancer une IllegalArgumentException si il ne trouve pas de correspondance de l'énumération.
Je ne veux pas utiliser toUpperCase ici, puisqu'il n'est pas toujours le cas de a -> A. Le cas réel est quelque chose comme cela uspsx -> USPS_EXPRESS. Est-il un moyen, je viens de mettre à jour mon code, u peut prendre un coup d'oeil?
J'ai ajouté du code qui fait ce que vous voulez (je pense). Vous pouvez mettre le code dans l'énumération lui-même.
Je vous remercie beaucoup. De me laisser tenter 😀
Excellent travail, merci beaucoup

OriginalL'auteur JustinKSU

Vous pouvez obtenir un Enum de la méthode valueOf ():

public void init(String s) {
    try {
        Shipper shipper = Shipper.valueOf(s.toUpperCase());

        shipperName.add(shipper);
    } catch(IllegalArgumentException e) {
        e.printStackTrace();
    }
}

EDIT:

Si ce n'est pas seulement un simple a -> Un cas, il pourrait être une idée pour créer une table de hachage avec clé=>valeur de paires:

private HashMap<String, Shipper> map;

public void init(String s) {
    if(map == null) {
        map = new HashMap<String, Shipper>();
        map.put("a", Shipper.A);
        ... //b => B code etc
    }

    if(map.containsKey(s)) {
        shipperName.add(map.get(s));
    } else {
        System.out.println("Error");
    }
}

J'espère que cela aide!

Je ne veux pas utiliser toUpperCase ici, puisqu'il n'est pas toujours le cas de a -> A. Le cas réel est quelque chose comme cela uspsx -> USPS_EXPRESS. Est-il un moyen, je viens de mettre à jour mon code, u peut prendre un coup d'oeil?
J'ai fait des modifications 🙂 j'espère que cela aide!

OriginalL'auteur Darkzaelus

Vous devez vous connecter pour publier un commentaire.