Java: 열거에 지정된 문자열이 포함되어 있는지 확인하시겠습니까?

Java: 열거에 지정된 문자열이 포함되어 있는지 확인하시겠습니까?

제 문제가 . 있는 은 '있다' - '있다'에 해당하는 ArrayList.contains();.

다음은 코드 문제의 예입니다.

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

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

아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아.ArrayListStrings여기서는 더 나은 경로이지만 다른 스위치나 케이스를 통해 열거형 내용을 실행해야 합니다.그래서 내 문제야.

이런 것이 존재하지 않는다고 가정하고 내가 어떻게 그것을 할 수 있겠는가?

대신 Apache commons lang3 lib 사용

 EnumUtils.isValidEnum(MyEnum.class, myValue)

이것으로 충분합니다.

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")false.true가 반환됩니다.

하시면 됩니다.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 MyData {
    ONE,
    TWO
}

@Test
public void test() {

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

한층 더 뛰어난 기능:

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

};

여기 몇 개의 도서관이 언급되었지만, 저는 실제로 찾고 있던 도서관이 그립습니다: 봄!

ObjectUtils#containsConstant가 있습니다.이러한 Constant는 기본적으로 대소문자를 구분하지 않지만 필요에 따라 엄격할 수 있습니다.다음과 같이 사용됩니다.

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

주의: 여기서는 대소문자를 구분하는 체크 사용법을 시연하기 위해 오버로드된 방법을 사용했습니다.부울을 생략하고 대소문자를 구분하지 않는 동작을 할 수 있습니다.

단, 큰 enum은 다른 enum처럼 Map 구현을 사용하지 않으므로 주의해야 합니다.

또한 valueOf: ObjectUtils#case의 대소문자를 구분하지 않습니다.인센시티브 밸류 Of

먼저 열거형을 목록으로 변환한 다음 목록 포함 메서드를 사용할 수 있습니다.

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
}

가지 전제 조건 " " " " " 。
) 시도/캐치는 .
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);
    }
}

이거 써도 돼

Enum {A1, A2, B1, B2}

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

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

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

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

반환: 지정한 값에 일치하는 스트림 요소가 있으면 true, 그렇지 않으면 false

없는 것 같은데 이렇게 할 수 있어요.

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

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

편집:

Richard가 사용하는 Strings로 변환하지 않으면 작동하지 않으므로 Richard의 버전을 참조하십시오.

Pablo의 회신을 value Of()와 결합하는 것은 어떨까요?

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

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

난 그냥 글을 쓸거야

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

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

이 접근방식을 사용하여 다음 항목을 확인할 수 있습니다.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");

이거면 되겠네요.

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

이 검증을 위해 다음 클래스를 만들었습니다.

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

Java 8 이후를 사용하고 있는 경우는, 다음의 조작을 실시할 수 있습니다.

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

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
}

사용할 수 있습니다.valueOf("a1")String으로 조회하는 경우

이것은 열거형입니다.이러한 값은 상수 값이기 때문에 스위치스테이트먼트에 포함되어 있는 경우는, 다음과 같은 조작을 실시합니다.

case: val1
case: val2

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

guava를 사용하면 더욱 간단합니다.

boolean isPartOfMyEnum(String myString){

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

}

이는 이전 방법의 모든 접근방식을 결합하여 동등한 성능을 가질 수 있습니다.@Richard H의 "Edit" 솔루션을 삽입하고 @bestss와 같은 비활성 값에 예외를 사용하는 모든 열거형에 사용할 수 있습니다.유일한 단점은 클래스를 지정해야 한다는 것입니다. 그러나 이는 이중 라이너로 바뀝니다.

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

값이 존재하는지 여부를 확인하고 enum 값을 반환받습니다.

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

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

com.google.common.base 를 사용할 수도 있습니다.에넘

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

Enums.getIfPresent(fooEnum.class, myVariable). is Present() ? Enums.getIfPresent(fooEnum.class, myVariable).get : fooEnum.다른이들

EnumUtils.isValidEnumApache commons lang3를 Import하는 경우 최적의 옵션이 될 수 있습니다.만약 팔로우하지 않는다면 대체 기능으로 사용할 수 있습니다.

private <T extends Enum<T>> boolean enumValueExists(Class<T> enumType, String value) {
    boolean result;
    try {
        Enum.valueOf(enumType, value);
        result = true;
    } catch (IllegalArgumentException e) {
        result = false;
    }
    return result;
}

그리고 다음과 같이 사용하세요.

if (enumValueExists(MyEnum.class, configValue)) {
    // happy code
} else {
    // angry code
}

목록을 반복하거나 예외를 잡는 것은 대부분의 경우 충분하지만 큰 에넘에 적합한 재사용 가능한 것을 찾고 있었습니다.결국 나는 이렇게 쓰고 만다.

public class EnumValidator {

    private final Set<String> values;

    private EnumValidator(Set<String> values) {
        this.values = values;
    }

    public static <T extends Enum<T>> EnumValidator of(Class<T> enumType){
        return new EnumValidator(Stream.of(enumType.getEnumConstants()).map(Enum::name).collect(Collectors.toSet()));
    }

    public boolean isPresent(String et){
        return values.contains(et);
    }
    
}

Java 8+ 스트림 + 설정 방법:

    // Build the set.
    final Set<String> mySet = Arrays//
      .stream(YourEnumHere.values())//
      .map(Enum::name)//
      .collect(Collectors.toSet());

    // Reuse the set for contains multiple times.
    mySet.contains(textA);
    mySet.contains(textB);
    ...

언급URL : https://stackoverflow.com/questions/4936819/java-check-if-enum-contains-a-given-string