Question Recherche Java enum par valeur de chaîne


Dire que j'ai une énumération qui est juste

public enum Blah {
    A, B, C, D
}

et je voudrais trouver la valeur enum d'une chaîne, par exemple "A" ce qui serait Blah.A. Comment serait-il possible de faire cela?

Est le Enum.valueOf() la méthode dont j'ai besoin? Si oui, comment pourrais-je l'utiliser?


1590
2018-03-02 22:56


origine


Réponses:


Oui, Blah.valueOf("A") te donnera Blah.A.

Notez que le nom doit être un exact match, y compris le cas: Blah.valueOf("a") et Blah.valueOf("A ") les deux jettent un IllegalArgumentException.

Les méthodes statiques valueOf() et values() sont créés au moment de la compilation et n'apparaissent pas dans le code source. Ils apparaissent dans Javadoc, cependant; par exemple, Dialog.ModalityType montre les deux méthodes.


1851
2018-03-02 22:57



Une autre solution si le texte n'est pas le même que la valeur d'énumération:

public enum Blah {
  A("text1"),
  B("text2"),
  C("text3"),
  D("text4");

  private String text;

  Blah(String text) {
    this.text = text;
  }

  public String getText() {
    return this.text;
  }

  public static Blah fromString(String text) {
    for (Blah b : Blah.values()) {
      if (b.text.equalsIgnoreCase(text)) {
        return b;
      }
    }
    return null;
  }
}

709
2018-06-03 10:57



Voici un utilitaire utile que j'utilise:

/**
 * A common method for all enums since they can't have another base class
 * @param <T> Enum type
 * @param c enum type. All enums must be all caps.
 * @param string case insensitive
 * @return corresponding enum, or null
 */
public static <T extends Enum<T>> T getEnumFromString(Class<T> c, String string) {
    if( c != null && string != null ) {
        try {
            return Enum.valueOf(c, string.trim().toUpperCase());
        } catch(IllegalArgumentException ex) {
        }
    }
    return null;
}

Ensuite, dans ma classe enum, j'ai généralement ceci pour sauver un peu de frappe:

public static MyEnum fromString(String name) {
    return getEnumFromString(MyEnum.class, name);
}

Si vos enums ne sont pas tous en majuscules, il suffit de changer le Enum.valueOf ligne.

Dommage que je ne puisse pas utiliser T.class pour Enum.valueOf comme T est effacé.


98
2017-11-12 15:52



Vous devriez également être prudent avec votre cas. Laissez-moi vous expliquer: faire Blah.valueOf("A") fonctionne, mais Blah.valueOf("a") ne fonctionnera pas. Puis encore Blah.valueOf("a".toUpperCase(Locale.ENGLISH)) travaillerait.

modifier
Modifié toUpperCase à toUpperCase(Locale.ENGLISH) basé sur tc. commentaire et le java docs

edit2 Sur Android, vous devriez utiliser Locale.US, comme Sulai souligne.


66
2018-05-09 16:33



Utilisez le motif de Joshua Bloch, Java efficace:

(simplifié pour la brièveté)

enum MyEnum {
  ENUM_1("A"),
  ENUM_2("B");

  private String name;

  private static final Map<String,MyEnum> ENUM_MAP;

  MyEnum (String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }

  // Build an immutable map of String name to enum pairs.
  // Any Map impl can be used.

  static {
    Map<String,MyEnum> map = new ConcurrentHashMap<String,MyEnum>();
    for (MyEnum instance : MyEnum.values()) {
      map.put(instance.getName(),instance);
    }
    ENUM_MAP = Collections.unmodifiableMap(map);
  }

  public static MyEnum get (String name) {
    return ENUM_MAP.get(name);
  }
}

Regarde aussi:

Oracle Java Exemple utilisant Enum et Map des instances

Ordre d'exécution des blocs statiques dans un type Enum

Comment puis-je rechercher une énumération Java à partir de sa valeur String


37
2018-06-15 16:37



Voici une méthode qui peut le faire pour tout Enum, et est insensible à la casse.

/** 
 * Finds the value of the given enumeration by name, case-insensitive. 
 * Throws an IllegalArgumentException if no match is found.  
 **/
public static <T extends Enum<T>> T valueOfIgnoreCase(
        Class<T> enumeration, String name) {

    for (T enumValue : enumeration.getEnumConstants()) {
        if (enumValue.name().equalsIgnoreCase(name)) {
            return enumValue;
        }
    }

    throw new IllegalArgumentException(String.format(
        "There is no value with name '%s' in Enum %s",
        name, enumeration.getName()
    ));
}

35
2017-12-01 21:53



En utilisant Blah.valueOf(string) est le meilleur mais vous pouvez utiliser Enum.valueOf(Blah.class, string) ainsi que.


28
2018-05-09 17:23



Si vous ne voulez pas écrire votre propre utilitaire, utilisez Google  bibliothèque:

Enums.getIfPresent(Blah.class, "A")

Contrairement à la fonction java intégrée, elle vérifie si A est présent dans Blah et ne lance pas d'exception.


22
2018-04-02 20:12



Vous pouvez avoir besoin de ceci:

public enum ObjectType {
    PERSON("Person");

    public String parameterName;

    ObjectType(String parameterName) {
        this.parameterName = parameterName;
    }

    public String getParameterName() {
        return this.parameterName;
    }

    //From String method will return you the Enum for the provided input string
    public static ObjectType fromString(String parameterName) {
        if (parameterName != null) {
            for (ObjectType objType : ObjectType.values()) {
                if (parameterName.equalsIgnoreCase(objType.parameterName)) {
                    return objType;
                }
            }
        }
        return null;
    }
}

Un ajout de plus:

   public static String fromEnumName(String parameterName) {
        if (parameterName != null) {
            for (DQJ objType : DQJ.values()) {
                if (parameterName.equalsIgnoreCase(objType.name())) {
                    return objType.parameterName;
                }
            }
        }
        return null;
    }

Cela vous renverra la valeur par un nom d'énumération stringifié, par exemple. Si vous fournissez "PERSON" dans fromEnumName, la valeur "Enum", c'est-à-dire "Person", vous sera renvoyée.


13
2017-07-02 11:54



Une autre façon de le faire en utilisant une méthode statique implicite name() d'Enum. name retournera la chaîne exacte utilisée pour créer cette énumération qui peut être utilisée pour vérifier la chaîne fournie:

public enum Blah {

    A, B, C, D;

    public static Blah getEnum(String s){
        if(A.name().equals(s)){
            return A;
        }else if(B.name().equals(s)){
            return B;
        }else if(C.name().equals(s)){
            return C;
        }else if (D.name().equals(s)){
            return D;
        }
        throw new IllegalArgumentException("No Enum specified for this string");
    }
}

Essai:

System.out.println(Blah.getEnum("B").name()); 

//it will print B  B

inspiration: 10 exemples d'Enum en Java


11
2017-11-29 05:02