Java: Sprawdź, czy enum zawiera podany ciąg?

Oto mój problem - szukam (jeśli w ogóle istnieje) odpowiednika enum ArrayList.contains();.

Oto próbka mojego problemu z kodem:

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

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

Teraz zdaję sobie sprawę, że opcja ArrayListof Stringsbyłaby tutaj lepszą trasą, ale muszę uruchomić zawartość wyliczenia za pomocą przełącznika / przypadku w innym miejscu. Stąd mój problem.

Zakładając, że coś takiego nie istnieje, jak mam się do tego zabrać?

To powinno wystarczyć:

public static boolean contains(String test) {

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

    return false;
}

W ten sposób nie musisz się martwić o późniejsze dodanie dodatkowych wartości wyliczenia, wszystkie są sprawdzane.

Edycja: Jeśli wyliczenie jest bardzo duże, możesz umieścić wartości w HashSet:

public static HashSet<String> getEnums() {

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

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

  return values;
}

Następnie możesz po prostu zrobić: values.contains("your string")co zwraca prawdę lub fałsz.

Zamiast tego użyj biblioteki Apache commons lang3

 EnumUtils.isValidEnum(MyEnum.class, myValue)

Możesz użyć 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
  }
}

Jeśli spodziewasz się, że sprawdzanie często kończy się niepowodzeniem, lepiej byłoby użyć prostej pętli, jak pokazały inne - jeśli twoje wyliczenia zawierają wiele wartości, być może builda HashSetlub coś podobnego z twoich wartości wyliczeniowych przekonwertowanych na ciąg i zapytaj o to HashSet.

Jeśli używasz Java 1.8, możesz wybrać Stream + Lambda, aby zaimplementować to:

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

Nawet lepiej:

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

};

Guavas Enums może być twoim przyjacielem

Na przykład to:

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

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

Możesz najpierw przekonwertować wyliczenie na List, a następnie użyć metody list zawiera

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
}

Wspomniano tutaj o kilku bibliotekach, ale tęsknię za tą, której tak naprawdę szukałem: Wiosna!

Istnieje ObjectUtils # includesConstant, która domyślnie nie rozróżnia wielkości liter, ale może być ścisła, jeśli chcesz. Jest używany w następujący sposób:

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

Uwaga: użyłem tutaj przeciążonej metody, aby zademonstrować, jak używać sprawdzania wielkości liter. Możesz pominąć wartość logiczną, aby zachowanie nie uwzględniało wielkości liter.

Uważaj jednak na duże wyliczenia, ponieważ nie używają implementacji Map, jak niektórzy ...

Jako bonus zapewnia również wariant valueOf: ObjectUtils # caseInsensitiveValueOf niewrażliwy na wielkość liter

Kilka założeń:
1) Brak try / catch, ponieważ jest to wyjątkowa kontrola przepływu
2) Metoda „zawiera” musi być szybka, ponieważ zwykle jest wykonywana kilka razy.
3) Przestrzeń nie jest ograniczona (typowe dla zwykłych rozwiązań)

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

Możesz tego użyć

YourEnum {A1, A2, B1, B2}

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

Aktualizacja sugerowana przez @ wightwulf1944 została uwzględniona, aby zwiększyć wydajność rozwiązania.

Myślę, że tak nie jest, ale możesz zrobić coś takiego:

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

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

Edytować:

Zapoznaj się z wersją Richarda, ponieważ jest bardziej odpowiednia, ponieważ nie zadziała, chyba że przekonwertujesz go na użycie ciągów, co robi Richards.

Strumienie Java zapewniają elegancki sposób na zrobienie tego

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

Zwraca: prawda, jeśli którykolwiek element strumienia pasuje do podanej wartości, w przeciwnym razie fałsz

Dlaczego nie połączyć odpowiedzi Pabla z wartością 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;
        }
}

To podejście można wykorzystać do sprawdzenia dowolnego Enum, możesz dodać go do Utilsklasy:

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

Użyj tego w ten sposób:

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

Stworzyłem następną klasę do tej walidacji

public class EnumUtils {

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

}

przykład użycia:

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

Możesz użyć, valueOf("a1")jeśli chcesz wyszukać ciąg znaków

Jest to wyliczenie, są to wartości stałe, więc jeśli jest w instrukcji przełącznika, robi coś takiego:

case: val1
case: val2

Dlaczego miałbyś wiedzieć, co jest zadeklarowane jako stała?

Z guawą jest to jeszcze prostsze:

boolean isPartOfMyEnum(String myString){

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

}

Łączy to wszystkie podejścia z poprzednich metod i powinno mieć równoważną wydajność. Może być używany dla dowolnego wyliczenia, wbudowuje rozwiązanie „Edytuj” z @Richard H i używa wyjątków dla nieprawidłowych wartości, takich jak @bestsss. Jedyny kompromis polega na tym, że należy określić klasę, ale to zmienia to w dwuliniowiec.

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")

rozwiązanie, aby sprawdzić, czy wartość jest obecna, a także uzyskać wartość wyliczenia w zamian:

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

Ten działa dla mnie:

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

Jeśli używasz Java 8 lub nowszej, możesz to zrobić:

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

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

Możesz zrobić to jako metodę zawierającą:

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

lub możesz po prostu użyć go ze swoim blokiem kodu:

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

możesz też użyć: com.google.common.base.Enums

Enums.getIfPresent (varEnum.class, varToLookFor) zwraca opcjonalny

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

Po prostu napisałbym

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

Enum # equals działa tylko w przypadku porównania obiektów.

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

enumsą dość potężne w Javie. Możesz łatwo dodać containsmetodę do swojego wyliczenia (tak jak dodasz metodę do klasy):

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

};