Java: Überprüfen Sie, ob enum eine bestimmte Zeichenfolge enthält?

Hier ist mein Problem - ich suche (falls es überhaupt existiert) das Enum-Äquivalent von ArrayList.contains();.

Hier ist ein Beispiel für mein Codeproblem:

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

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

Jetzt ist mir klar, dass ein ArrayListvon Stringshier der bessere Weg wäre, aber ich muss meinen Enum-Inhalt durch einen Schalter / Fall an einer anderen Stelle laufen lassen. Daher mein Problem.

Angenommen, so etwas gibt es nicht. Wie könnte ich das tun?

Dies sollte es tun:

public static boolean contains(String test) {

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

    return false;
}

Auf diese Weise müssen Sie sich später keine Gedanken mehr über das Hinzufügen zusätzlicher Aufzählungswerte machen. Alle werden überprüft.

Bearbeiten: Wenn die Aufzählung sehr groß ist, können Sie die Werte in ein HashSet einfügen:

public static HashSet<String> getEnums() {

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

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

  return values;
}

Dann können Sie einfach Folgendes tun: values.contains("your string")was true oder false zurückgibt.

Verwenden Sie stattdessen die Apache Commons Lang3 Lib

 EnumUtils.isValidEnum(MyEnum.class, myValue)

Sie können verwenden 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
  }
}

Wenn Sie erwarten, dass die Prüfung häufig fehlschlägt, ist es möglicherweise besser, eine einfache Schleife zu verwenden, wie andere gezeigt haben. Wenn Ihre Aufzählungen viele Werte enthalten , konvertieren Sie möglicherweise Builda HashSetoder ähnliche Ihrer Aufzählungswerte in eine Zeichenfolge und fragen Sie diese ab HashSet.

Wenn Sie Java 1.8 verwenden, können Sie Stream + Lambda auswählen, um dies zu implementieren:

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 könnte dein Freund sein

Wie zB das:

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

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

Noch besser:

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

};

Sie können zuerst die Aufzählung in Liste konvertieren und dann die Methode Liste enthält verwenden

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
}

Ein paar Bibliotheken wurden hier erwähnt, aber ich vermisse die, nach der ich eigentlich gesucht habe: Frühling!

Es gibt die ObjectUtils # includesConstant, bei der die Groß- und Kleinschreibung standardmäßig nicht berücksichtigt wird, die jedoch bei Bedarf streng sein kann. Es wird so verwendet:

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

Hinweis: Ich habe hier die überladene Methode verwendet, um die Verwendung der Groß- und Kleinschreibung zu demonstrieren. Sie können den Booleschen Wert weglassen, um die Groß- und Kleinschreibung nicht zu berücksichtigen.

Seien Sie jedoch vorsichtig mit großen Aufzählungen, da diese die Map-Implementierung nicht wie manche verwenden ...

Als Bonus bietet es auch eine Variante von valueOf: ObjectUtils # caseInsensitiveValueOf, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird

Einige Annahmen:
1) Kein Versuch / Fang, da es sich um eine außergewöhnliche Flusskontrolle handelt.
2) Die Methode "enthält" muss schnell sein, da sie normalerweise mehrmals ausgeführt wird.
3) Der Platz ist nicht begrenzt (üblich für gewöhnliche Lösungen)

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

Sie können dies verwenden

YourEnum {A1, A2, B1, B2}

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

Das von @ wightwulf1944 vorgeschlagene Update wurde integriert, um die Lösung effizienter zu gestalten.

Ich glaube nicht, aber Sie können so etwas tun:

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

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

Bearbeiten:

Bitte lesen Sie Richards Version davon, da dies angemessener ist, da dies nur funktioniert, wenn Sie es in Strings konvertieren, was Richards tut.

Java Streams bietet eine elegante Möglichkeit, dies zu tun

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

Rückgabe: true, wenn Elemente des Streams mit dem angegebenen Wert übereinstimmen, andernfalls false

Warum nicht Pablos Antwort mit einem valueOf () kombinieren?

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

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

Dieser Ansatz kann verwendet werden, um alle zu überprüfen Enum. Sie können ihn einer UtilsKlasse hinzufügen :

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

Verwenden Sie es so:

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

Ich habe die nächste Klasse für diese Validierung erstellt

public class EnumUtils {

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

}

Anwendungsbeispiel:

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

Sie können verwenden, valueOf("a1")wenn Sie nach String suchen möchten

Es ist eine Aufzählung, das sind konstante Werte. Wenn es also in einer switch-Anweisung steht, macht es einfach so etwas:

case: val1
case: val2

Warum sollten Sie auch wissen müssen, was als Konstante deklariert ist?

Mit Guave ist es noch einfacher:

boolean isPartOfMyEnum(String myString){

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

}

Dies kombiniert alle Ansätze früherer Methoden und sollte eine gleichwertige Leistung aufweisen. Es kann für jede Aufzählung verwendet werden, fügt die "Edit" -Lösung von @Richard H ein und verwendet Ausnahmen für ungültige Werte wie @bestsss. Der einzige Nachteil ist, dass die Klasse angegeben werden muss, aber dies macht dies zu einem Zweiliner.

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

Lösung, um zu überprüfen, ob auch ein Wert vorhanden ist.

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

Dieser funktioniert für mich:

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

Wenn Sie Java 8 oder höher verwenden, können Sie dies tun:

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

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

Sie können es als enthält-Methode erstellen:

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

oder Sie können es einfach mit Ihrem Codeblock verwenden:

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

Sie können auch Folgendes verwenden: com.google.common.base.Enums

Enums.getIfPresent (varEnum.class, varToLookFor) gibt eine Option zurück

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

Ich würde einfach schreiben,

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

Enum # equals funktioniert nur mit Objektvergleich.

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

enumsind in Java ziemlich mächtig. Sie können containsIhrer Aufzählung ganz einfach eine Methode hinzufügen (wie Sie einer Klasse eine Methode hinzufügen würden):

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

};