Digamos que tengo una enumeración que es solo
public enum Blah {
A, B, C, D
}
y me gustaría encontrar el valor enum de una cadena, por ejemplo "A" cuál podría ser 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?
Sí, Blah.valueOf("A") Te regalaré Blah.A.
Tenga en cuenta que el nombre debe ser un exacto coincidencia, 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.ModalityType muestra ambos métodos.
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;
}
}
Aquí hay una utilidad ingeniosa 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 enum, generalmente tengo esto para guardar algo de tipeo:
public static MyEnum fromString(String name) {
return getEnumFromString(MyEnum.class, name);
}
Si sus enumeraciones no son mayúsculas, simplemente cambie la Enum.valueOf línea.
Lástima que no puedo usar T.class para Enum.valueOf como T es borrado
También debe tener cuidado con su caso. Déjame explicarte: haciendo Blah.valueOf("A") funciona, pero Blah.valueOf("a") no trabajará. Entonces otra vez Blah.valueOf("a".toUpperCase(Locale.ENGLISH)) trabajaría.
editar
Cambiado toUpperCase a toUpperCase(Locale.ENGLISH) Residencia en tc. comentario y el documentos de java
edit2
En Android debes usar Locale.US, como sulai señala.
Usa 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:
Oracle Java Example utilizando Enum y Map of instances
Orden de ejecución de bloques estáticos en un tipo Enum
¿Cómo puedo buscar una enumeración Java a partir de su valor de cadena?
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()
));
}
Utilizando Blah.valueOf(string) es mejor pero puedes usar Enum.valueOf(Blah.class, string) también.