Java: ¿Verificar si enum contiene una cadena dada?

Aquí está mi problema: estoy buscando (si es que existe) el enum equivalente de ArrayList.contains(); .

Aquí hay una muestra de mi problema de código:

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

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

Ahora, me doy cuenta de que una ArrayListdeStrings sería la mejor ruta aquí, pero tengo que ejecutar mi contenido de enumeración a través de un interruptor / caso en otro lugar. De ahí mi problema.

Suponiendo que algo como esto no exista, ¿cómo podría hacerlo?

Esto debería hacerlo:

public static boolean contains(String test) {

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

    return false;
}

De esta manera, no tiene que preocuparse por agregar valores de enumeración adicionales más adelante, todos están marcados.

Editar: si la enumeración es muy grande, puede pegar los valores en un HashSet:

public static HashSet<String> getEnums() {

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

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

  return values;
}

Entonces puedes simplemente hacer: lo values.contains("your string")que devuelve verdadero o falso.

Utilice la biblioteca lang3 de Apache commons en su lugar

 EnumUtils.isValidEnum(MyEnum.class, myValue)

Puedes usar 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 espera que la verificación falle con frecuencia, es mejor que use un bucle simple como lo han demostrado otros, si sus enumeraciones contienen muchos valores, quizás builda HashSeto similar de sus valores de enumeración convertidos en una cadena y consulte eso HashSet.

Si está utilizando Java 1.8, puede elegir Stream + Lambda para implementar esto:

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

Aun mejor:

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 podría ser tu amigo

Por ejemplo, esto:

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

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

Primero puede convertir la enumeración a Lista y luego usar el método de lista contiene

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
}

Pocas suposiciones:
1) Sin intento / captura, ya que es un control de flujo excepcional
2) El método 'contiene' debe ser rápido, ya que generalmente se ejecuta varias veces.
3) El espacio no es limitado (común para soluciones ordinarias)

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

Aquí se han mencionado un par de bibliotecas, pero extraño la que estaba buscando: ¡Primavera!

Existe ObjectUtils # usesConstant, que no distingue entre mayúsculas y minúsculas de forma predeterminada, pero puede ser estricto si lo desea. Se usa así:

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

Nota: Utilicé el método sobrecargado aquí para demostrar cómo usar la comprobación de mayúsculas y minúsculas. Puede omitir el booleano para tener un comportamiento que no distinga entre mayúsculas y minúsculas.

Sin embargo, tenga cuidado con las enumeraciones grandes, ya que no usan la implementación del Mapa como algunos lo hacen ...

Como beneficio adicional, también proporciona una variante entre mayúsculas y minúsculas del valueOf: ObjectUtils # caseInsensitiveValueOf

Puedes usar esto

YourEnum {A1, A2, B1, B2}

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

La actualización sugerida por @ wightwulf1944 se incorpora para hacer que la solución sea más eficiente.

No creo que exista, pero puedes hacer algo como esto:

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

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

Editar:

Vea la versión de Richard de esto, ya que es más apropiado ya que esto no funcionará a menos que lo convierta para usar Strings, lo que Richards hace.

Java Streams proporciona una forma elegante de hacerlo

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

Devuelve: verdadero si alguno de los elementos de la secuencia coincide con el valor proporcionado; de lo contrario, falso

¿Por qué no combinar la respuesta de Pablo con 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;
        }
}

Este enfoque se puede usar para verificar cualquiera Enum, puede agregarlo a una Utilsclase:

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

Úselo de esta manera:

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

Creé la siguiente clase para esta validación

public class EnumUtils {

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

}

ejemplo de uso:

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

Puede usar valueOf("a1")si desea buscar por String

Es una enumeración, esos son valores constantes, por lo que si está en una declaración de interruptor, solo está haciendo algo como esto:

case: val1
case: val2

Además, ¿por qué necesitarías saber qué se declara como una constante?

Con guayaba es aún más simple:

boolean isPartOfMyEnum(String myString){

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

}

Esto combina todos los enfoques de los métodos anteriores y debe tener un rendimiento equivalente. Se puede usar para cualquier enumeración, incluye la solución "Editar" de @Richard H y usa Excepciones para valores no válidos como @bestsss. El único inconveniente es que la clase necesita ser especificada, pero eso convierte esto en un trazador de líneas.

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

solución para verificar si el valor está presente y obtener un valor de enumeración a cambio:

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

Esta funciona para mí:

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

Si está utilizando Java 8 o superior, puede hacer esto:

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

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

Puede hacerlo como un método contiene:

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

o simplemente puede usarlo con su bloque de código:

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

también puedes usar: com.google.common.base.Enums

Enums.getIfPresent (varEnum.class, varToLookFor) devuelve un Opcional

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

Yo solo escribiría

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

Enum # equals solo funciona con la comparación de objetos.

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

enumson bastante poderosos en Java. Puede agregar fácilmente un containsmétodo a su enumeración (como agregaría un método a una clase):

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

};