Java: Kiểm tra xem enum có chứa một chuỗi đã cho không?

Đây là vấn đề của tôi - Tôi đang tìm kiếm (nếu nó còn tồn tại) tương đương với enum ArrayList.contains();.

Đây là một ví dụ về vấn đề mã của tôi:

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

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

Bây giờ, tôi nhận ra rằng một ArrayListtrong số Stringsđó sẽ là con đường tốt hơn ở đây nhưng tôi phải chạy nội dung enum của mình thông qua một công tắc / trường hợp ở nơi khác. Do đó vấn đề của tôi.

Giả sử một cái gì đó như thế này không tồn tại, làm thế nào tôi có thể thực hiện nó?

Điều này nên làm điều đó:

public static boolean contains(String test) {

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

    return false;
}

Cách này có nghĩa là bạn không phải lo lắng về việc thêm các giá trị enum sau này, tất cả chúng đều được kiểm tra.

Chỉnh sửa: Nếu enum rất lớn, bạn có thể dán các giá trị trong Hashset:

public static HashSet<String> getEnums() {

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

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

  return values;
}

Sau đó, bạn có thể làm: values.contains("your string")trả về đúng hay sai.

Sử dụng Apache commons lang3 lib thay thế

 EnumUtils.isValidEnum(MyEnum.class, myValue)

Bạn có thể dùng 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
  }
}

Nếu bạn mong đợi kiểm tra thất bại thường xuyên, bạn có thể tốt hơn bằng cách sử dụng một vòng lặp đơn giản như những gì khác đã hiển thị - nếu enum của bạn chứa nhiều giá trị, có thể là builda HashSethoặc tương tự các giá trị enum của bạn được chuyển đổi thành một chuỗi và HashSetthay vào đó truy vấn .

Nếu bạn đang sử dụng Java 1.8, bạn có thể chọn Stream + Lambda để thực hiện điều này:

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 có thể là bạn của bạn

Giống như ví dụ này:

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

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

Thậm chí còn tốt hơn:

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

};

Trước tiên, bạn có thể chuyển đổi enum thành Danh sách và sau đó sử dụng danh sách chứa phương thức

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
}

Một vài thư viện đã được đề cập ở đây, nhưng tôi nhớ cái mà tôi thực sự đang tìm kiếm: Mùa xuân!

Có ObjectUtils # chứaConstant không phân biệt chữ hoa chữ thường, nhưng có thể nghiêm ngặt nếu bạn muốn. Nó được sử dụng như thế này:

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

Lưu ý: Tôi đã sử dụng phương pháp quá tải ở đây để trình bày cách sử dụng kiểm tra phân biệt chữ hoa chữ thường. Bạn có thể bỏ qua boolean để có hành vi không nhạy cảm.

Tuy nhiên, hãy cẩn thận với số tiền lớn, vì họ không sử dụng triển khai Bản đồ như một số ...

Như một phần thưởng, nó cũng cung cấp một biến thể không phân biệt chữ hoa của valueOf: ObjectUtils # caseInsensitiveValueOf

Vài giả định:
1) Không thử / bắt, vì đây là
phương pháp kiểm soát luồng đặc biệt 2) Phương pháp 'chứa' phải nhanh chóng, vì nó thường chạy nhiều lần.
3) Không gian không giới hạn (phổ biến cho các giải pháp thông thường)

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

Bạn có thể sử dụng cái này

YourEnum {A1, A2, B1, B2}

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

Cập nhật được đề xuất bởi @ wightwulf1944 được kết hợp để làm cho giải pháp hiệu quả hơn.

Tôi không nghĩ là có, nhưng bạn có thể làm một cái gì đó như thế này:

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

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

Biên tập:

Vui lòng xem phiên bản này của Richard vì nó phù hợp hơn vì nó sẽ không hoạt động trừ khi bạn chuyển đổi nó sang sử dụng Chuỗi, điều mà Richards thực hiện.

Luồng Java cung cấp cách thức thanh lịch để làm điều đó

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

Trả về: true nếu bất kỳ phần tử nào của luồng khớp với giá trị được cung cấp, nếu không thì sai

Tại sao không kết hợp trả lời của Pablo với 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;
        }
}

Cách tiếp cận này có thể được sử dụng để kiểm tra bất kỳ Enum, bạn có thể thêm nó vào một Utilslớp:

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

Sử dụng theo cách này:

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

Tôi đã tạo lớp tiếp theo cho xác nhận này

public class EnumUtils {

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

}

ví dụ về việc sử dụng:

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

Bạn có thể sử dụng valueOf("a1")nếu bạn muốn tra cứu bằng String

Nó là một enum, đó là các giá trị không đổi, vì vậy nếu trong câu lệnh chuyển đổi, nó chỉ làm một cái gì đó như thế này:

case: val1
case: val2

Ngoài ra tại sao bạn cần phải biết những gì được khai báo là hằng số?

Với ổi thậm chí còn đơn giản hơn:

boolean isPartOfMyEnum(String myString){

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

}

Điều này kết hợp tất cả các phương pháp từ các phương pháp trước đó và nên có hiệu suất tương đương. Nó có thể được sử dụng cho bất kỳ enum nào, nội tuyến giải pháp "Chỉnh sửa" từ @Richard H và sử dụng Ngoại lệ cho các giá trị không hợp lệ như @bestsss. Sự đánh đổi duy nhất là lớp cần được chỉ định, nhưng điều đó biến điều này thành một lớp hai.

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

giải pháp để kiểm tra xem giá trị có hiện diện hay không và nhận lại giá trị enum:

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

Cái này hoạt động với tôi:

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

Nếu bạn đang sử dụng Java 8 trở lên, bạn có thể làm điều này:

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

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

Bạn có thể làm cho nó như là một phương thức chứa:

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

hoặc bạn chỉ có thể sử dụng nó với khối mã của bạn:

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

bạn cũng có thể sử dụng: com.google.common.base.Enums

Enums.get IfPftime (varEnum. Class, varToLookFor) trả về một Tùy chọn

Enums.get IfPftime (fooEnum. Class, myVariable) .isPftime ()? Enums.get IfPftime (fooEnum. Class, myVariable) .get: fooEnum.OTHERS

Tôi sẽ chỉ viết

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

Enum # bằng chỉ hoạt động với so sánh đối tượng.

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

enumkhá mạnh mẽ trong Java. Bạn có thể dễ dàng thêm một containsphương thức vào enum của mình (như bạn sẽ thêm một phương thức vào một lớp):

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

};