Java: ตรวจสอบว่า enum มีสตริงที่กำหนดหรือไม่

นี่เป็นปัญหาของฉัน - ฉันกำลังมองหา (ถ้ามันยังมีอยู่) เทียบเท่า enum ArrayList.contains();ของ

นี่คือตัวอย่างของปัญหารหัสของฉัน:

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

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

ตอนนี้ฉันรู้ว่าหนึ่งArrayListในStringsนั้นจะเป็นเส้นทางที่ดีกว่าที่นี่ แต่ฉันต้องเรียกใช้เนื้อหา enum ของฉันผ่านสวิตช์ / เคสที่อื่น ดังนั้นปัญหาของฉัน

สมมติว่าไม่มีอะไรแบบนี้ฉันจะทำยังไงต่อ?

สิ่งนี้ควรทำ:

public static boolean contains(String test) {

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

    return false;
}

วิธีนี้หมายความว่าคุณไม่ต้องกังวลเกี่ยวกับการเพิ่มค่า enum เพิ่มเติมในภายหลังพวกเขาทั้งหมดจะถูกตรวจสอบ

แก้ไข:ถ้า enum มีขนาดใหญ่มากคุณสามารถใส่ค่าใน 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")ซึ่งผลตอบแทนจริงหรือเท็จ

ใช้ 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
  }
}

หากคุณคิดว่าการตรวจสอบที่จะล้มเหลวบ่อยครั้งคุณอาจจะดีกว่าการใช้ห่วงง่ายๆกับคนอื่น ๆ ได้แสดงให้เห็น - ถ้า enums ของคุณมีหลายค่าบางที builda HashSetหรือคล้ายกันของค่า enum ของคุณแปลงเป็นสตริงและแบบสอบถามที่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");
    }
}

คุณสามารถแปลง enum เป็น List ก่อนจากนั้นใช้ list มีวิธีการ

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
}

มีการพูดถึงห้องสมุดคู่กันที่นี่ แต่ฉันคิดถึงสิ่งที่ฉันกำลังมองหา: ฤดูใบไม้ผลิ!

มีObjectUtils # containConstantซึ่งไม่คำนึงถึงขนาดตัวพิมพ์โดยค่าเริ่มต้น แต่สามารถเข้มงวดได้ถ้าคุณต้องการ มันถูกใช้อย่างนี้:

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

หมายเหตุ: ฉันใช้วิธีโอเวอร์โหลดที่นี่เพื่อสาธิตวิธีใช้การตรวจสอบด้วยตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ คุณสามารถละเว้นบูลีนเพื่อให้มีพฤติกรรมที่ไม่สนใจตัวพิมพ์เล็กและใหญ่

ระวังด้วย enums ขนาดใหญ่เนื่องจากพวกเขาไม่ได้ใช้การใช้งานแผนที่เนื่องจากบางคนทำ ...

เป็นโบนัสนอกจากนี้ยังมีชุดตัวพิมพ์เล็กและตัวพิมพ์เล็กของ valueOf: ObjectUtils # caseInsensitiveValueOf

สมมติฐานบางประการ:
1) ไม่ต้องลอง / จับเนื่องจากมีการควบคุมการไหลที่ยอดเยี่ยม
2) เมธอด 'contain' จะต้องรวดเร็วเนื่องจากมักจะทำงานหลายครั้ง
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;
}

แก้ไข:

โปรดดูเวอร์ชันนี้ของ Richard เนื่องจากเหมาะสมกว่าเนื่องจากจะไม่ทำงานเว้นแต่คุณจะแปลงเป็น Strings ซึ่ง Richards ทำ

Java Streams เป็นวิธีที่ยอดเยี่ยมในการทำเช่นนั้น

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

คืนค่า: จริงถ้าองค์ประกอบใด ๆ ของกระแสตรงกับค่าที่ระบุมิฉะนั้นเป็นเท็จ

ทำไมไม่รวมคำตอบของ 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;
        }
}

วิธีนี้สามารถใช้ในการตรวจสอบใด ๆ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")ถ้าคุณต้องการค้นหาด้วย String

มันคือ enum, มันคือค่าคงที่ดังนั้นถ้ามันอยู่ในคำสั่ง switch มันแค่ทำอะไรแบบนี้:

case: val1
case: val2

ทำไมคุณต้องรู้ว่าอะไรคือค่าคงที่?

ด้วยฝรั่งมันง่ายกว่ามาก:

boolean isPartOfMyEnum(String myString){

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

}

วิธีนี้รวมวิธีการทั้งหมดจากวิธีการก่อนหน้านี้และควรมีประสิทธิภาพที่เทียบเท่า มันสามารถใช้สำหรับ enum ใด ๆ แทรกแนวทาง "แก้ไข" จาก @Richard H และใช้ข้อยกเว้นสำหรับค่าที่ไม่ถูกต้องเช่น @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")

วิธีการแก้ปัญหาเพื่อตรวจสอบว่ามีมูลค่าหรือไม่และรับค่า enum เป็นการตอบแทน:

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) 

คุณสามารถทำให้มันเป็นวิธีการบรรจุ:

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) จะส่งคืนตัวเลือก

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 # เท่ากับใช้งานได้กับการเปรียบเทียบวัตถุเท่านั้น

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

enumค่อนข้างทรงพลังใน Java คุณสามารถเพิ่มcontainsวิธีการใน enum ของคุณได้อย่างง่ายดาย(เช่นคุณจะเพิ่มวิธีการในชั้นเรียน):

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

};