Comment vérifier si une chaîne donnée est une partie de tout Enum en Java?

Le plus simple (et généralement plus efficace) est comme suit:

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

et puis vous appelez isInEnum(filter, Filter.class).

Ici est un Java 8/flux version de Louis Wasserman réponse. (Vous pouvez aussi mettre cette méthode directement dans l'énumération de la classe, et de supprimer l'un des paramètres)

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

Éviter l'utilisation d'une boucle pour procéder à la validation.

Je conseille valueOf. Cette méthode est intégrée dans les énumérations, et pourrait être considérée pour compiler l'optimisation du temps.

Ce serait semblable à la mise en œuvre d'une statique Map<String,EnumType> pour optimiser la recherche, une autre considération que vous pouvez prendre.

Inconvénient est que vous devez utiliser l'exception d'un mécanisme de gestion d'attraper un non-valeur d'enum.

Exemple

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

Également noter qu'avec le type décrit ci-dessus mise en œuvre, votre code est beaucoup plus propre lors de l'appel. Votre principale serait maintenant ressembler à quelque chose comme:

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

    //...

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

Puis l'autre option est d'utiliser une Carte statique. Vous pouvez employer une telle approche pour mettre en cache toutes sortes d'indexation basées sur d'autres propriétés. Dans l'exemple ci-dessous, j'autorise chaque valeur d'énumération d'une liste de noms d'alias. L'index de recherche, dans ce cas, être sensible à la casse, en forçant les majuscules.

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