enums que es - ¿Cómo obtener un valor de enumeración de un valor de cadena en Java?





12 Answers

Otra solución si el texto no es el mismo que el 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;
  }
}
netbeans crear enumeracion

Digamos que tengo un enum que es justo

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

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

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




También debes tener cuidado con tu caso. Déjame explicarte: hacer Blah.valueOf("A") funciona, pero Blah.valueOf("a") no funciona. Luego, nuevamente Blah.valueOf("a".toUpperCase(Locale.ENGLISH)) funcionaría.

editar
Se cambió a toUpperCase(Locale.ENGLISH) a toUpperCase(Locale.ENGLISH) basado en tc. comentar y los documentos java

edit2 En Android debes usar Locale.US , como señala sulai .




Aquí hay un método que puede hacerlo para cualquier Enum, y es insensible a 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()
    ));
}



Si no desea escribir su propia utilidad, utilice la biblioteca de guava de Google:

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

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




Mis 2 centavos aquí: usando Java8 Streams + comprobando 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));
    }
}

** EDIT **

Cambió el nombre de la función a fromString() desde que la nombró usando esa convención, obtendrá algunos beneficios del lenguaje Java en sí; por ejemplo:

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



Otra forma de hacerlo es mediante el uso de un name() método estático implícito name() de Enum. nombre devolverá la cadena exacta utilizada para crear esa enumeración que se puede usar para verificar contra 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




Para agregar a las respuestas anteriores, y abordar algunas de las discusiones sobre nulos y NPE, estoy usando las opciones de guayaba para manejar los casos ausentes / no válidos. Esto funciona muy bien para URI / análisis de 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 algo más de información sobre cómo evitar nulos con Opcional: https://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional




El método O (1) está inspirado en el código generado por ahorro que utiliza un mapa de hash.

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

}



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

  • Puede usar el método name() para obtener el nombre de las constantes de Enum. El literal de cadena utilizado para escribir constantes de enumeración es su nombre.
  • Similar método de values() se puede utilizar para obtener una matriz de todas las constantes Enum de un tipo Enum.
  • Y para la pregunta formulada, puede usar el método valueOf() para convertir cualquier constante String to 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 método valueOf() devuelve una constante Enum Gender.MALE, nombre de llamada que devuelve "MALE" .




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

valueOf() lanza dos excepciones diferentes en los casos en que no le gusta su entrada.

  • IllegalArgumentException
  • NullPointerExeption

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

Así que aquí hay un método reutilizable que escribí que nos permite definir un Enum predeterminado 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;
        }
    }

Úsalo 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
}



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



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 devolverla cuando no se encuentran las otras (incluso en una base que no distingue entre mayúsculas y minúsculas) en lugar de nula (lo que significa que no hay valor). Por eso utilizo 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;
}



Related


Tags

java   enums