¿Cómo obtener un valor de enumeración de un valor de cadena en Java?

Digamos que tengo una enumeración que es solo

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

y me gustaría encontrar el valor de enumeración de una cadena, por ejemplo, "A"cuál sería Blah.A. ¿Cómo sería posible hacer esto?

¿Es el Enum.valueOf()método que necesito? Si es así, ¿cómo usaría esto?

Sí, Blah.valueOf("A")te lo daré Blah.A.

Tenga en cuenta que el nombre debe ser una coincidencia exacta , incluido el caso: Blah.valueOf("a")y Blah.valueOf("A ")ambos arrojan un IllegalArgumentException.

Los métodos estáticos valueOf()y values()se crean en tiempo de compilación y no aparecen en el código fuente. Sin embargo, aparecen en Javadoc; por ejemplo, Dialog.ModalityTypemuestra ambos métodos.

Otra solución si el texto no es igual al valor de enumeración:

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

Aquí hay una ingeniosa utilidad que uso:

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

Luego, en mi clase de enumeración, generalmente tengo esto para guardar algo de escritura:

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

Si sus enumeraciones no son todas mayúsculas, simplemente cambie la Enum.valueOflínea.

Es una lástima que no puedo utilizar T.classpara Enum.valueOfque Tse borra.

Use el patrón de Joshua Bloch, Java efectivo :

(simplificado por brevedad)

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

Ver también:

Ejemplo de Oracle Java con Enum y Map de instancias

Orden de ejecución de bloques estáticos en un tipo Enum

¿Cómo puedo buscar una enumeración de Java a partir de su valor de cadena

También debe tener cuidado con su caso. Déjame explicarte: hacer Blah.valueOf("A")trabajos, pero Blah.valueOf("a")no funcionará. Entonces otra vez Blah.valueOf("a".toUpperCase(Locale.ENGLISH))funcionaría.

editar
Cambiado toUpperCasea toUpperCase(Locale.ENGLISH)basado en tc. comentario y los documentos de Java

edit2 En Android deberías usar Locale.US, como señala sulai .

Aquí hay un método que puede hacerlo para cualquier Enum, y no distingue entre mayúsculas y minúsculas.

/** 
 * 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()
    ));
}

Usar Blah.valueOf(string)es lo mejor, pero también puedes usarlo Enum.valueOf(Blah.class, string).

En Java 8 o posterior, usando Streams :

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 Optional<Blah> fromText(String text) {
        return Arrays.stream(values())
          .filter(bl -> bl.text.equalsIgnoreCase(text))
          .findFirst();
    }
}

Si no desea escribir su propia utilidad, use Google guayaba biblioteca:

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

A diferencia de la función Java incorporada, le permite verificar si A está presente en Blah y no arroja una excepción.

Mis 2 centavos aquí: usar Java8 Streams + verificar una cadena exacta:

public enum MyEnum {
    VALUE_1("Super"),
    VALUE_2("Rainbow"),
    VALUE_3("Dash"),
    VALUE_3("Rocks");

    private final String value;

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

    /**
     * @return the Enum representation for the given string.
     * @throws IllegalArgumentException if unknown string.
     */
    public static MyEnum fromString(String s) throws IllegalArgumentException {
        return Arrays.stream(MyEnum.values())
                .filter(v -> v.value.equals(s))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("unknown value: " + s));
    }
}

** EDITAR **

Cambió el nombre de la función a, fromString()ya que al nombrarla usando esa convención, obtendrá algunos beneficios del lenguaje Java; por ejemplo:

1. Conversión directa de tipos en la anotación HeaderParam

Es posible que necesite esto:

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

Una adición más:

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

Esto le devolverá el Valor por un Nombre de Enum. Stringified. Por ejemplo, si proporciona "PERSONA" en fromEnumName, le devolverá el Valor de Enum, es decir, "Persona"

Otra forma de hacerlo mediante el método estático implícito name()de Enum. name devolverá la cadena exacta utilizada para crear esa enumeración que se puede utilizar para verificar la cadena proporcionada:

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

Pruebas:

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

//it will print B  B

inspiración: 10 ejemplos de Enum en Java

Solución utilizando bibliotecas de guayaba. El método getPlanet () no distingue entre mayúsculas y minúsculas, por lo que getPlanet ("MerCUrY") devolverá Planet.MERCURY.

package com.universe.solarsystem.planets;
import org.apache.commons.lang3.StringUtils;
import com.google.common.base.Enums;
import com.google.common.base.Optional;

//Pluto and Eris are dwarf planets, who cares!
public enum Planet {
   MERCURY,
   VENUS,
   EARTH,
   MARS,
   JUPITER,
   SATURN,
   URANUS,
   NEPTUNE;

   public static Planet getPlanet(String name) {
      String val = StringUtils.trimToEmpty(name).toUpperCase();
      Optional <Planet> possible = Enums.getIfPresent(Planet.class, val);
      if (!possible.isPresent()) {
         throw new IllegalArgumentException(val + "? There is no such planet!");
      }
      return possible.get();
   }
}

Para agregar a las respuestas anteriores y abordar algunas de las discusiones sobre nulos y NPE, estoy usando Guava Optionals para manejar casos ausentes / inválidos. Esto funciona muy bien para el análisis de URI / parámetros.

public enum E {
    A,B,C;
    public static Optional<E> fromString(String s) {
        try {
            return Optional.of(E.valueOf(s.toUpperCase()));
        } catch (IllegalArgumentException|NullPointerException e) {
            return Optional.absent();
        }
    }
}

Para aquellos que no lo saben, aquí hay más información sobre cómo evitar nulos con Opcional: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional

En Java 8, el patrón de Mapa estático es aún más fácil y es mi método preferido. Si desea usar Enum con Jackson, puede anular toString y usar eso en lugar de nombre, luego anotar con@JsonValue

public enum MyEnum {
    BAR,
    BAZ;
    private static final Map<String, MyEnum> MAP = Stream.of(MyEnum.values()).collect(Collectors.toMap(Enum::name, Function.identity()));
    public static MyEnum fromName(String name){
        return MAP.get(name);
    }
}

public enum MyEnumForJson {
    BAR("bar"),
    BAZ("baz");
    private static final Map<String, MyEnumForJson> MAP = Stream.of(MyEnumForJson.values()).collect(Collectors.toMap(Object::toString, Function.identity()));
    private final String value;

    MyEnumForJson(String value) {
        this.value = value;
    }

    @JsonValue
    @Override
    public String toString() {
        return value;
    }

    public static MyEnumForJson fromValue(String value){
        return MAP.get(value);
    }
}

public static MyEnum getFromValue(String value) {
    MyEnum resp = null;
    MyEnum nodes[] = values();
    for(int i = 0; i < nodes.length; i++) {
        if(nodes[i].value.equals(value)) {
            resp = nodes[i];
            break;
        }
    }
    return resp;
}

Método O (1) inspirado en el código generado por ahorro que utiliza un hashmap.

public enum USER {
        STUDENT("jon",0),TEACHER("tom",1);

        private static final Map<String, Integer> map = new HashMap<>();

        static {
                for (USER user : EnumSet.allOf(USER.class)) {
                        map.put(user.getTypeName(), user.getIndex());
                }
        }

        public static int findIndexByTypeName(String typeName) {
                return map.get(typeName);
        }

        private USER(String typeName,int index){
                this.typeName = typeName;
                this.index = index;
        }
        private String typeName;
        private int index;
        public String getTypeName() {
                return typeName;
        }
        public void setTypeName(String typeName) {
                this.typeName = typeName;
        }
        public int getIndex() {
                return index;
        }
        public void setIndex(int index) {
                this.index = index;
        }

}

Enum es muy útil, he estado usando Enummucho para agregar una descripción para algunos campos en diferentes idiomas, como el siguiente ejemplo:

public enum Status {

    ACT(new String[] { "Accepted", "مقبول" }),
    REJ(new String[] { "Rejected", "مرفوض" }),
    PND(new String[] { "Pending", "في الانتظار" }),
    ERR(new String[] { "Error", "خطأ" }),
    SNT(new String[] { "Sent", "أرسلت" });

    private String[] status;

    public String getDescription(String lang) {
        return lang.equals("en") ? status[0] : status[1];
    }

    Status(String[] status) {
        this.status = status;
    }
}

Y luego puede recuperar la descripción dinámicamente en función del código de idioma pasado al getDescription(String lang)método, por ejemplo:

String statusDescription = Status.valueOf("ACT").getDescription("en");

¿Qué pasa?

public enum MyEnum {
    FIRST,
    SECOND,
    THIRD;

    public static Optional<MyEnum> fromString(String value){
        try{
            return Optional.of(MyEnum.valueOf(value));
        }catch(Exception e){
            return Optional.empty();
        }
    }
}

java.lang.Enum define varios métodos útiles, que están disponibles para todo tipo de enumeración en Java:

• Puede usar el name()método para obtener el nombre de las constantes Enum. El literal de cadena utilizado para escribir constantes enum es su nombre.
• De manera similar values(), se puede usar un método para obtener una matriz de todas las constantes Enum de un tipo Enum.
• Y para la pregunta formulada, puede usar el valueOf()método para convertir cualquier cadena a constante Enum en Java, como se muestra a continuación.

public class EnumDemo06 {
    public static void main(String args[]) {
        Gender fromString = Gender.valueOf("MALE");
        System.out.println("Gender.MALE.name() : " + fromString.name());
    }

    private enum Gender {
        MALE, FEMALE;
    }
}

Output:
Gender.MALE.name() : MALE

En este fragmento de código, el valueOf()método devuelve una constante Enum Gender.MALE, llamando al nombre en ese retorno "MALE".

La biblioteca commons-lang de Apache tiene una función estática org.apache.commons.lang3.EnumUtils.getEnum que asignará una Cadena a su tipo Enum. Esencialmente, la misma respuesta que Geoffreys, pero ¿por qué tirar la tuya cuando ya está en la naturaleza?

Agregando a la respuesta mejor calificada, con una útil utilidad ...

valueOf() lanza dos Excepciones diferentes en casos donde no le gusta su entrada.

• IllegalArgumentException
• NullPointerExeption

Si sus requisitos son tales que no tiene ninguna garantía de que su String definitivamente coincida con un valor de enumeración, por ejemplo, si los datos de String provienen de una base de datos y podrían contener una versión anterior de la enumeración, entonces deberá manejarlos a menudo...

Así que aquí hay un método reutilizable que escribí que nos permite definir una Enum predeterminada que se devolverá si la Cadena que pasamos no coincide.

private static <T extends Enum<T>> T valueOf( String name , T defaultVal) {
        try {
            return Enum.valueOf(defaultVal.getDeclaringClass() , name);
        } catch (IllegalArgumentException | NullPointerException e) {
            return defaultVal;
        }
    }

Úselo así:

public enum MYTHINGS {
    THINGONE,
    THINGTWO
}

public static void main(String [] asd) {
  valueOf("THINGTWO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGTWO
  valueOf("THINGZERO" , MYTHINGS.THINGONE);//returns MYTHINGS.THINGONE
}

Como switchtodavía no se ha mencionado una versión, la presento (reutilizando la enumeración de OP):

  private enum Blah {
    A, B, C, D;

    public static Blah byName(String name) {
      switch (name) {
        case "A":
          return A;
        case "B":
          return B;
        case "C":
          return C;
        case "D":
          return D;
        default:
          throw new IllegalArgumentException(
            "No enum constant " + Blah.class.getCanonicalName() + "." + name);
      }
    }
  }

Dado que esto no le da ningún valor adicional al valueOf(String name)método, solo tiene sentido definir un método adicional si queremos tener un comportamiento diferente. Si no queremos plantear una IllegalArgumentException, podemos cambiar la implementación a:

  private enum Blah {
    A, B, C, D;

    public static Blah valueOfOrDefault(String name, Blah defaultValue) {
      switch (name) {
        case "A":
          return A;
        case "B":
          return B;
        case "C":
          return C;
        case "D":
          return D;
        default:
          if (defaultValue == null) {
            throw new NullPointerException();
          }
          return defaultValue;
      }
    }
  }

Al proporcionar un valor por defecto mantenemos el contrato de Enum.valueOf(String name)sin lanzar una IllegalArgumentException de esa manera que en ningún caso nullse devuelve. Por lo tanto, arrojamos un NullPointerExceptionsi el nombre es nully en caso de defaultsi defaultValuees null. Así es como valueOfOrDefaultfunciona.

Este enfoque adopta el diseño de la Mapinterfaz que proporciona un método a Map.getOrDefault(Object key, V defaultValue)partir de Java 8.

Otra utilidad que captura de forma inversa. Usando un valor que identifica esa enumeración, no de su nombre.

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.EnumSet;

public class EnumUtil {

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose a 
     * public method return value of this Enum is 
     * equal to <code>valor</code>.<br/>
     * Such method should be unique public, not final and static method 
     * declared in Enum.
     * In case of more than one method in match those conditions
     * its first one will be chosen.
     * 
     * @param enumType
     * @param value
     * @return 
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value) {
        String methodName = getMethodIdentifier(enumType);
        return from(enumType, value, methodName);
    }

    /**
     * Returns the <code>Enum</code> of type <code>enumType</code> whose  
     * public method <code>methodName</code> return is 
     * equal to <code>value</code>.<br/>
     *
     * @param enumType
     * @param value
     * @param methodName
     * @return
     */
    public static <E extends Enum<E>> E from(Class<E> enumType, Object value, String methodName) {
        EnumSet<E> enumSet = EnumSet.allOf(enumType);
        for (E en : enumSet) {
            try {
                String invoke = enumType.getMethod(methodName).invoke(en).toString();
                if (invoke.equals(value.toString())) {
                    return en;
                }
            } catch (Exception e) {
                return null;
            }
        }
        return null;
    }

    private static String getMethodIdentifier(Class<?> enumType) {
        Method[] methods = enumType.getDeclaredMethods();
        String name = null;
        for (Method method : methods) {
            int mod = method.getModifiers();
            if (Modifier.isPublic(mod) && !Modifier.isStatic(mod) && !Modifier.isFinal(mod)) {
                name = method.getName();
                break;
            }
        }
        return name;
    }
}

Ejemplo:

public enum Foo {
    ONE("eins"), TWO("zwei"), THREE("drei");

    private String value;

    private Foo(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

EnumUtil.from(Foo.class, "drei")regresa Foo.THREE, porque se usará getValuepara hacer coincidir "drei", que es un método público único, no final y no estático en Foo. En caso de Foo tiene más de método público, no es definitiva y no estática, por ejemplo, getTranslateque devuelve "Drei", el otro método puede ser utilizado: EnumUtil.from(Foo.class, "drei", "getTranslate").

Solución Kotlin

Crea una extensión y luego llama valueOf<MyEnum>("value"). Si el tipo no es válido, obtendrá nulo y tendrá que manejarlo

inline fun <reified T : Enum<T>> valueOf(type: String): T? {
    return try {
        java.lang.Enum.valueOf(T::class.java, type)
    } catch (e: Exception) {
        null
    }
}

Alternativamente, puede establecer un valor predeterminado, llamar valueOf<MyEnum>("value", MyEnum.FALLBACK)y evitar una respuesta nula. Puede ampliar su enumeración específica para que el valor predeterminado sea automático

inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T {
    return try {
        java.lang.Enum.valueOf(T::class.java, type)
    } catch (e: Exception) {
        default
    }
}

O si quieres ambos, haz el segundo:

inline fun <reified T : Enum<T>> valueOf(type: String, default: T): T = valueOf<T>(type) ?: default

Me gusta usar este tipo de proceso para analizar comandos como cadenas en enumeraciones. Normalmente tengo una de las enumeraciones como "desconocida", por lo que es útil que la devuelvan cuando no se encuentran las otras (incluso sin distinción de mayúsculas y minúsculas) en lugar de nulas (lo que significa que no hay valor). Por lo tanto, uso este enfoque.

static <E extends Enum<E>> Enum getEnumValue(String what, Class<E> enumClass) {
    Enum<E> unknown=null;
    for (Enum<E> enumVal: enumClass.getEnumConstants()) {  
        if (what.compareToIgnoreCase(enumVal.name()) == 0) {
            return enumVal;
        }
        if (enumVal.name().compareToIgnoreCase("unknown") == 0) {
            unknown=enumVal;
        }
    }  
    return unknown;
}

La forma más rápida de obtener el nombre de enum es crear un mapa de texto y valor de enumeración cuando se inicia la aplicación, y para obtener el nombre, llame a la función Blah.getEnumName ():

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

    private String text;
    private HashMap<String, String> map;
    Blah(String text) {
    this.text = text;
    }

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

    static{
      createMapOfTextAndName();
    }

    public static void createMapOfTextAndName() {
        map = new HashMap<String, String>();
        for (Blah b : Blah.values()) {
             map.put(b.getText(),b.name());
        }
    }
    public static String getEnumName(String text) {
        return map.get(text.toLowerCase());
    } 
}