Java : 열거 형에 지정된 문자열이 포함되어 있는지 확인하십시오.

여기 내 문제가 있습니다-열거 형에 해당하는 열거 형을 찾고 있습니다 (존재하는 경우) ArrayList.contains();.

내 코드 문제의 샘플은 다음과 같습니다.

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

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

이제는 ArrayList 의 Strings가 더 나은 경로 있지만 스위치 / 케이스를 통해 열거 형 내용을 실행해야합니다. 따라서 내 문제.

이와 같은 것이 존재하지 않는다고 가정하면 어떻게 할 수 있습니까?

이것은해야합니다 :

public static boolean contains(String test) {

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

    return false;
}

이 방법은 나중에 열거 형 값을 추가하는 것에 대해 걱정할 필요가 없으며 모두 확인됩니다.

편집 : 열거 형이 매우 큰 경우 HashSet에 값을 붙일 수 있습니다.

public static HashSet<String> getEnums() {

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

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

  return values;
}

그런 다음 수행 할 수 있습니다 : values.contains("your string")true 또는 false를 반환합니다.

대신 Apache commons lang3 lib를 사용하십시오.

 EnumUtils.isValidEnum(MyEnum.class, myValue)

당신이 사용할 수있는 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
  }
}

검사가 자주 실패 할 것으로 예상되는 경우, 다른 루프가 보여준 것처럼 간단한 루프를 사용하는 것이 좋습니다. 열거 형에 많은 값이 포함 된 경우 ( 아마도 HashSet열거 형 또는 이와 유사한 열거 형 값이 문자열로 변환되어 HashSet대신 쿼리 됨) .

Java 1.8을 사용하는 경우 Stream + Lambda를 선택하여이를 구현할 수 있습니다.

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

더 나은 :

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 는 당신의 친구가 될 수 있습니다

예를 들면 다음과 같습니다.

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

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

먼저 열거 형을 List로 변환 한 다음 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
}

여기에 몇 개의 라이브러리가 언급되었지만 실제로 찾고 있던 라이브러리가 그리워졌습니다 : Spring!

거기입니다 ObjectUtils # containsConstant 기본적으로 케이스를 구분하지 않습니다,하지만 당신이 원하는 경우에 엄격한 될 수 있습니다. 다음과 같이 사용됩니다 :

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

참고 : 대소 문자를 구분하는 확인을 사용하는 방법을 보여주기 위해 오버로드 된 방법을 사용했습니다. 부울을 생략하여 대소 문자를 구분하지 않는 동작을 수행 할 수 있습니다.

그래도 큰 enum에주의하십시오. 일부처럼 Map 구현을 사용하지 않기 때문에 ...

또한, valueOf의 대소 문자를 구분하지 않는 변형을 제공합니다. ObjectUtils # caseInsensitiveValueOf

몇 가지 가정 :
1) 예외적 인 흐름 제어이기 때문에 시도 / 캐치가 없습니다.
2) '포함'방법은 일반적으로 여러 번 실행되므로 신속해야합니다.
3) 공간은 제한되지 않습니다 (일반 솔루션의 경우 일반적 임)

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

이것을 사용할 수 있습니다

YourEnum {A1, A2, B1, B2}

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

솔루션의 효율성을 높이기 위해 @ wightwulf1944에서 제안한 업데이트가 통합되었습니다.

나는 생각하지 않지만 다음과 같이 할 수 있습니다.

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

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

편집하다:

Richards가 수행하는 String을 사용하도록 변환하지 않으면 작동하지 않기 때문에 Richard의 버전이 더 적합하므로 참조하십시오.

Java Streams는이를위한 우아한 방법을 제공합니다

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

스트림의 요소가 제공된 값과 일치하면 true, 그렇지 않으면 false

Pablo의 답장과 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;
        }
}

이 접근법은 any를 확인하는 데 사용할 수 있으며 클래스에 Enum추가 할 수 있습니다 Utils.

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

이 방법으로 사용하십시오 :

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

이 유효성 검사를 위해 다음 수업을 만들었습니다.

public class EnumUtils {

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

}

사용 예 :

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

valueOf("a1")문자열로 조회하려는 경우 사용할 수 있습니다

그것은 열거 형이며, 상수 값이므로 switch 문에 다음과 같은 일을하면됩니다.

case: val1
case: val2

또한 상수로 선언 된 것을 알아야하는 이유는 무엇입니까?

구아바를 사용하면 훨씬 간단합니다.

boolean isPartOfMyEnum(String myString){

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

}

이것은 이전 방법의 모든 접근 방식을 결합하며 동등한 성능을 가져야합니다. 모든 열거 형에 사용할 수 있으며 @Richard H의 "Edit"솔루션에 인라인하고 @bestsss와 같은 유효하지 않은 값에는 예외를 사용합니다. 유일한 단점은 클래스를 지정해야하지만 이것이 두 개의 라이너로 바뀐다는 것입니다.

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

값이 있는지 여부를 확인하는 솔루션은 열거 형 값을 반환합니다.

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

이것은 나를 위해 작동합니다 :

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

Java 8 이상을 사용중인 경우 다음을 수행 할 수 있습니다.

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

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

contains 메소드로 만들 수 있습니다.

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

또는 코드 블록과 함께 사용할 수 있습니다.

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

다음을 사용할 수도 있습니다 : com.google.common.base.Enums

Enums.getIfPresent (varEnum.class, varToLookFor)는 Optional을 반환합니다

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

난 그냥 쓸거야

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

Enum # equals는 객체 비교에서만 작동합니다.

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

enumJava에서 매우 강력합니다. contains클래스에 메소드를 추가하는 것처럼 메소드를 열거 형에 쉽게 추가 할 수 있습니다 .

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

};