¿Cómo comprobar si una cadena dada es una parte de cualquier Enum en Java?

Question

Tengo dos enumeraciones diferentes y quiero poder mostrar si una cadena dada es parte de una colección enum. este es mi código:

public class Check { 
    public enum Filter{SIZE, DATE, NAME}; 
    public enum Action{COPY, DELETE, REMOVE}; 

    public boolean isInEnum(String value, Enum e){ 
     // check if string value is a part of a given enum 
     return false; 
    } 

    public void main(){ 
     String filter = "SIZE"; 
     String action = "DELETE"; 
       // check the strings 
     isInEnum(filter, Filter); 
     isInEnum(action, Action); 
    } 
} 

Eclipse dice que en las dos últimas líneas de "filtro no se puede resolver de una variable", pero aparte de eso, parece que el parámetro de enumeración en la función "isInEnum" está mal .

Algo está muy mal aquí ¿alguien puede ayudar?

Answer 1

La manera más simple (y por lo general más eficiente) es el siguiente:

public <E extends Enum<E>> boolean isInEnum(String value, Class<E> enumClass) { 
    for (E e : enumClass.getEnumConstants()) { 
    if(e.name().equals(value)) { return true; } 
    } 
    return false; 
} 

y luego se llama a isInEnum(filter, Filter.class).

Answer 2

Evite utilizar un bucle para realizar la validación.

Yo sugeriría usar valueOf. Este método está incorporado en las enumeraciones y podría considerarse para la optimización del tiempo de compilación.

Esto sería similar a implementar un Map<String,EnumType> estático para optimizar la búsqueda, otra consideración que puede tomar.

El inconveniente es que tendría que usar el mecanismo de manejo de excepciones para capturar un valor que no sea enum.

Ejemplo

public enum DataType { 
    //... 
    static public boolean has(String value) { 
    if (value== null) return false; 
    try { 
     // In this implementation - I want to ignore the case 
     // if you want otherwise ... remove .toUpperCase() 
     return valueOf(value.toUpperCase()); 
    } catch (IllegalArgumentException x) { 
     // the uggly part ... 
     return false; 
    } 
    } 
} 

También tenga en cuenta que con la implementación del tipo anterior, su código es mucho más limpio al llamar. Su principal ahora se vería así:

public void main(){ 
    String filter = "SIZE"; 
    String action = "DELETE"; 

    // ... 

    if (Filter.has(filter) && Action.has(action)) { 
     // Appropriate action 
    } 
} 

Luego, la otra opción mencionada es utilizar un Mapa estático. Puede emplear dicho enfoque para almacenar en caché todo tipo de indexación en función de otras propiedades también. En el ejemplo siguiente, permito que cada valor enum tenga una lista de nombres de alias. El índice de búsqueda en este caso será insensible a mayúsculas y minúsculas, forzando a mayúsculas.

public enum Command { 
    DELETE("del","rm","remove"), 
    COPY("cp"), 
    DIR("ls"); 

    private static final Map<String,Command> ALIAS_MAP = new HashMap<String,Command>(); 
    static { 
    for (Command type:Command.values()) { 
     ALIAS_MAP.put(type.getKey().toUpper(),type); 
     for (String alias:type.aliases) ALIAS_MAP.put(alias.toUpper(),type); 
    } 
    } 

    static public boolean has(String value) { 
    return ALIAS_MAP.containsKey(value.toUpper()); 
    } 

    static public Command fromString(String value) { 
    if (value == null) throw new NullPointerException("alias null"); 
    Command command = ALIAS_MAP.get(value); 
    if (command == null) throw new IllegalArgumentException("Not an alias: "+value); 
    return command; 
    } 

    private List<String> aliases; 
    private Command(String... aliases) { 
    this.aliases = Arrays.asList(aliases); 
    } 
} 

Answer 3

Aquí hay una versión de Java 8/streams de la respuesta de Louis Wasserman. (También se puede poner este método directamente en la clase Enum, y quitar uno de los parámetros)

public boolean isInEnum(String value, Class<E> enumClass) { 
    return Arrays.stream(enumClass.getEnumConstants()).anyMatch(e -> e.name().equals(value)); 
    } 

Answer 4

no tengo suficientes puntos para comentar sobre la respuesta de Simón Torre directamente, pero aquí es el método para la segunda forma mencionó que va directamente en la clase de enumeración en sí:

public static boolean isInEnum(String value) { 
    return Arrays.stream(EnumClassNameGoesHere.values()).anyMatch(e -> e.name().equals(value)); 
} 

Answer 5

Si no les importa usar Apache Commons biblioteca lang3 se puede utilizar el siguiente código:

EnumUtils.isValidEnum(Filter.class, filter) 

De acuerdo con el docs:

Este método difiere de Enum.valueOf (java.lang.Class, java.lang.String), ya que no produce una excepción para un nombre de enumeración no válido.