Java: vérifier si enum contient une chaîne donnée?

Voici mon problème - je cherche (s'il existe) l'équivalent enum de ArrayList.contains();.

Voici un exemple de mon problème de code:

enum choices {a1, a2, b1, b2};

if(choices.???(a1)}{
//do this
} 

Maintenant, je me rends compte qu'un ArrayListof Stringsserait la meilleure route ici, mais je dois exécuter mon contenu enum via un commutateur / boîtier ailleurs. D'où mon problème.

En supposant que quelque chose comme ça n'existe pas, comment pourrais-je le faire?

Cela devrait le faire:

public static boolean contains(String test) {

    for (Choice c : Choice.values()) {
        if (c.name().equals(test)) {
            return true;
        }
    }

    return false;
}

De cette façon, vous n'avez pas à vous soucier d'ajouter des valeurs d'énumération supplémentaires plus tard, elles sont toutes vérifiées.

Edit: Si l'énumération est très grande, vous pouvez coller les valeurs dans un HashSet:

public static HashSet<String> getEnums() {

  HashSet<String> values = new HashSet<String>();

  for (Choice c : Choice.values()) {
      values.add(c.name());
  }

  return values;
}

Ensuite, vous pouvez simplement faire: values.contains("your string")qui renvoie vrai ou faux.

Utilisez la librairie Apache commons lang3 à la place

 EnumUtils.isValidEnum(MyEnum.class, myValue)

Vous pouvez utiliser Enum.valueOf()

enum Choices{A1, A2, B1, B2};

public class MainClass {
  public static void main(String args[]) {
    Choices day;

    try {
       day = Choices.valueOf("A1");
       //yes
    } catch (IllegalArgumentException ex) {  
        //nope
  }
}

Si vous vous attendez à ce que la vérification échoue souvent, vous feriez peut-être mieux d'utiliser une simple boucle comme d'autres l'ont montré - si vos enums contiennent de nombreuses valeurs, peut-être builda HashSetou similaire de vos valeurs d'énumération converties en une chaîne et interrogez-la à la HashSetplace.

Si vous utilisez Java 1.8, vous pouvez choisir Stream + Lambda pour implémenter ceci:

public enum Period {
    DAILY, WEEKLY
};

//This is recommended
Arrays.stream(Period.values()).anyMatch((t) -> t.name().equals("DAILY1"));
//May throw java.lang.IllegalArgumentException
Arrays.stream(Period.values()).anyMatch(Period.valueOf("DAILY")::equals);

Guavas Enums pourrait être votre ami

Comme par exemple ceci:

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

    if (!Enums.getIfPresent(MyData.class, "THREE").isPresent()) {
        System.out.println("THREE is not here");
    }
}

Encore mieux:

enum choices {
   a1, a2, b1, b2;

  public static boolean contains(String s)
  {
      for(choices choice:values())
           if (choice.name().equals(s)) 
              return true;
      return false;
  } 

};

Vous pouvez d'abord convertir l'énumération en liste, puis utiliser la méthode list contains

enum Choices{A1, A2, B1, B2};

List choices = Arrays.asList(Choices.values());

//compare with enum value 
if(choices.contains(Choices.A1)){
   //do something
}

//compare with String value
if(choices.contains(Choices.valueOf("A1"))){
   //do something
}

Quelques hypothèses:
1) Pas de try / catch, car il s'agit d'un contrôle de flux exceptionnel
2) La méthode «contient» doit être rapide, car elle s'exécute généralement plusieurs fois.
3) L'espace n'est pas limité (courant pour les solutions ordinaires)

import java.util.HashSet;
import java.util.Set;

enum Choices {
    a1, a2, b1, b2;

    private static Set<String> _values = new HashSet<>();

    // O(n) - runs once
    static{
        for (Choices choice : Choices.values()) {
            _values.add(choice.name());
        }
    }

    // O(1) - runs several times
    public static boolean contains(String value){
        return _values.contains(value);
    }
}

Quelques bibliothèques ont été mentionnées ici, mais celle que je recherchais me manque: le printemps!

Il y a le ObjectUtils # containsConstant qui est insensible à la casse par défaut, mais peut être strict si vous le souhaitez. Il est utilisé comme ceci:

if(ObjectUtils.containsConstant(Choices.values(), "SOME_CHOISE", true)){
// do stuff
}

Remarque: j'ai utilisé la méthode surchargée ici pour montrer comment utiliser la vérification sensible à la casse. Vous pouvez omettre le booléen pour avoir un comportement insensible à la casse.

Soyez prudent avec les grandes énumérations, car elles n'utilisent pas l'implémentation de Map comme certains le font ...

En prime, il fournit également une variante insensible à la casse de valueOf: ObjectUtils # caseInsensitiveValueOf

Vous pouvez utiliser ceci

YourEnum {A1, A2, B1, B2}

boolean contains(String str){ 
    return Sets.newHashSet(YourEnum.values()).contains(str);
}                                  

La mise à jour suggérée par @ wightwulf1944 est intégrée pour rendre la solution plus efficace.

Je ne pense pas que ce soit le cas, mais vous pouvez faire quelque chose comme ceci:

enum choices {a1, a2, b1, b2};

public static boolean exists(choices choice) {
   for(choice aChoice : choices.values()) {
      if(aChoice == choice) {
         return true;
      }
   }
   return false;
}

Éditer:

Veuillez consulter la version de Richard car elle est plus appropriée car cela ne fonctionnera pas à moins que vous ne la convertissiez pour utiliser des chaînes, ce que fait Richards.

Java Streams offre un moyen élégant de le faire

Stream.of(MyEnum.values()).anyMatch(v -> v.name().equals(strValue))

Renvoie: vrai si des éléments du flux correspondent à la valeur fournie, sinon faux

Pourquoi ne pas combiner la réponse de Pablo avec un valueOf ()?

public enum Choices
{
    a1, a2, b1, b2;

    public static boolean contains(String s) {
        try {
            Choices.valueOf(s);
            return true;
        } catch (Exception e) {
            return false;
        }
}

Cette approche peut être utilisée pour vérifier n'importe quel Enum, vous pouvez l'ajouter à une Utilsclasse:

public static <T extends Enum<T>> boolean enumContains(Class<T> enumerator, String value)
{
    for (T c : enumerator.getEnumConstants()) {
        if (c.name().equals(value)) {
            return true;
        }
    }
    return false;
}

Utilisez-le de cette façon:

boolean isContained = Utils.enumContains(choices.class, "value");

J'ai créé la classe suivante pour cette validation

public class EnumUtils {

    public static boolean isPresent(Enum enumArray[], String name) {
        for (Enum element: enumArray ) {
            if(element.toString().equals(name))
                return true;
        }
        return false;
    }

}

exemple d'utilisation:

public ArrivalEnum findArrivalEnum(String name) {

    if (!EnumUtils.isPresent(ArrivalEnum.values(), name))
        throw new EnumConstantNotPresentException(ArrivalEnum.class,"Arrival value must be 'FROM_AIRPORT' or 'TO_AIRPORT' ");

    return ArrivalEnum.valueOf(name);
}

Vous pouvez utiliser valueOf("a1")si vous souhaitez rechercher par chaîne

C'est une énumération, ce sont des valeurs constantes, donc si c'est dans une instruction switch, il fait juste quelque chose comme ceci:

case: val1
case: val2

Aussi, pourquoi auriez-vous besoin de savoir ce qui est déclaré comme constante?

Avec la goyave, c'est encore plus simple:

boolean isPartOfMyEnum(String myString){

return Lists.newArrayList(MyEnum.values().toString()).contains(myString);

}

Cela combine toutes les approches des méthodes précédentes et devrait avoir des performances équivalentes. Il peut être utilisé pour n'importe quelle énumération, en ligne avec la solution "Edit" de @Richard H, et utilise des exceptions pour les valeurs invalides comme @bestsss. Le seul compromis est que la classe doit être spécifiée, mais cela transforme cela en deux lignes.

import java.util.EnumSet;

public class HelloWorld {

static enum Choices {a1, a2, b1, b2}

public static <E extends Enum<E>> boolean contains(Class<E> _enumClass, String value) {
    try {
        return EnumSet.allOf(_enumClass).contains(Enum.valueOf(_enumClass, value));    
    } catch (Exception e) {
        return false; 
    }
}

public static void main(String[] args) {
    for (String value : new String[] {"a1", "a3", null}) {
        System.out.println(contains(Choices.class, value));
    }
}

}

com.google.common.collect.Sets.newHashSet(MyEnum.values()).contains("myValue")

solution pour vérifier si la valeur est présente et obtenir la valeur enum en retour:

protected TradeType getEnumType(String tradeType) {
    if (tradeType != null) {
        if (EnumUtils.isValidEnum(TradeType.class, tradeType)) {
            return TradeType.valueOf(tradeType);
        }
    }
    return null;
}

Celui-ci fonctionne pour moi:

Arrays.asList(YourEnum.values()).toString().contains("valueToCheck");

Si vous utilisez Java 8 ou supérieur, vous pouvez le faire:

boolean isPresent(String testString){
      return Stream.of(Choices.values()).map(Enum::name).collect(Collectors.toSet()).contains(testString);
}

  Set.of(CustomType.values())
     .contains(customTypevalue) 

Vous pouvez en faire une méthode contient:

enum choices {a1, a2, b1, b2};
public boolean contains(String value){
    try{
        EnumSet.allOf(choices.class).contains(Enum.valueOf(choices.class, value));
        return true;
    }catch (Exception e) {
        return false;
    }
}

ou vous pouvez simplement l'utiliser avec votre bloc de code:

try{
    EnumSet.allOf(choices.class).contains(Enum.valueOf(choices.class, "a1"));
    //do something
}catch (Exception e) {
    //do something else
}

vous pouvez également utiliser: com.google.common.base.Enums

Enums.getIfPresent (varEnum.class, varToLookFor) renvoie une option

Enums.getIfPresent (fooEnum.class, myVariable) .isPresent ()? Enums.getIfPresent (fooEnum.class, myVariable) .get: fooEnum.OTHERS

J'écrirais juste

Arrays.stream(Choice.values()).map(Enum::name).collect(Collectors.toList()).contains("a1");

Enum # equals ne fonctionne qu'avec la comparaison d'objets.

public boolean contains(Choices value) {
   return EnumSet.allOf(Choices.class).contains(value);
}

enumsont assez puissants en Java. Vous pouvez facilement ajouter une containsméthode à votre énumération (comme vous ajouteriez une méthode à une classe):

enum choices {
  a1, a2, b1, b2;

  public boolean contains(String s)
  {
      if (s.equals("a1") || s.equals("a2") || s.equals("b1") || s.equals("b2")) 
         return true;
      return false;
  } 

};