Comment vérifier si une chaîne donnée fait partie d'un Enum donné en Java ?

Question

J'ai deux enums différents et je veux être capable d'indiquer si une valeur donnée de donnée fait partie d'une collection d'enum. Voici mon code :

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 dit que dans les deux dernières lignes "Filter can't be resolved to a variable" mais à part cela, il semble que le paramètre Enum dans la fonction "isInEnum" soit erroné.

Quelque chose ne va pas du tout ici, quelqu'un peut-il m'aider ?

Answer 1

La méthode la plus simple (et généralement la plus efficace) est la suivante :

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 ensuite vous appelez isInEnum(filter, Filter.class) .

Answer 2

Si l'utilisation de la bibliothèque Apache commons lang3 ne vous dérange pas, vous pouvez utiliser le code suivant :

EnumUtils.isValidEnum(Filter.class, filter)

Selon le docs :

Cette méthode diffère de Enum.valueOf(java.lang.Class, java.lang.String) en ce qu'elle ne lève pas d'exception pour un nom d'enum invalide.

Answer 3

Voici une version Java 8/streams de la réponse de Louis Wasserman. (Vous pouvez aussi mettre cette méthode directement dans la classe Enum, et enlever un des paramètres)

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

Answer 4

Je n'ai pas assez de points pour commenter directement la réponse de Simon Tower, mais voici la méthode pour la deuxième façon qu'il a mentionnée qui va directement dans la classe enum elle-même :

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

Answer 5

Évitez d'utiliser une boucle pour effectuer la validation.

Je suggère d'utiliser valueOf . Cette méthode est intégrée aux enums, et peut être envisagée pour une optimisation au moment de la compilation.

Cela reviendrait à mettre en œuvre un système statique Map<String,EnumType> pour optimiser la recherche, une autre considération que vous pouvez prendre.

L'inconvénient est qu'il faudrait utiliser le mécanisme de traitement des exceptions pour attraper une valeur non numérique.

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

Notez également qu'avec l'implémentation du type ci-dessus, votre code est beaucoup plus propre lors de l'appel. Votre main ressemblerait maintenant à quelque chose comme :

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

    // ...

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

L'autre option mentionnée consiste à utiliser une carte statique. Vous pouvez utiliser une telle approche pour mettre en cache toute sorte d'indexation basée sur d'autres propriétés également. Dans l'exemple ci-dessous, j'autorise chaque valeur d'enum à avoir une liste de noms d'alias. L'index de recherche dans ce cas sera insensible à la casse, en forçant la majuscule.

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