Java: Periksa apakah enum berisi string yang diberikan?

Inilah masalah saya - saya sedang mencari (jika ada) yang setara dengan enum ArrayList.contains();.

Berikut ini contoh masalah kode saya:

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

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

Sekarang, saya menyadari bahwa salah ArrayListsatu Stringsakan menjadi rute yang lebih baik di sini, tetapi saya harus menjalankan konten enum saya melalui saklar / case di tempat lain. Karena itu masalah saya.

Dengan asumsi sesuatu seperti ini tidak ada, bagaimana saya bisa melakukannya?

Ini harus dilakukan:

public static boolean contains(String test) {

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

    return false;
}

Dengan cara ini berarti Anda tidak perlu khawatir tentang menambahkan nilai enum tambahan nanti, semuanya diperiksa.

Sunting: Jika enum sangat besar Anda bisa menempelkan nilai dalam HashSet:

public static HashSet<String> getEnums() {

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

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

  return values;
}

Maka Anda bisa melakukan: values.contains("your string")yang mengembalikan benar atau salah.

Gunakan Apache commons lang3 lib sebagai gantinya

 EnumUtils.isValidEnum(MyEnum.class, myValue)

Kamu bisa memakai 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
  }
}

Jika Anda mengharapkan pemeriksaan gagal sering, Anda mungkin lebih baik menggunakan loop sederhana seperti yang telah ditunjukkan - jika enum Anda mengandung banyak nilai, mungkin builda HashSetatau nilai enum serupa yang dikonversi ke string dan kueri itu HashSetsebagai gantinya.

Jika Anda menggunakan Java 1.8, Anda dapat memilih Stream + Lambda untuk mengimplementasikan ini:

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

Bahkan lebih baik:

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

};

Enak jambu biji bisa menjadi teman Anda

Seperti misalnya ini:

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

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

Anda dapat terlebih dahulu mengonversi enum ke Daftar dan kemudian menggunakan metode daftar berisi

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
}

Beberapa asumsi:
1) Tidak mencoba / menangkap, karena itu adalah kontrol aliran yang luar biasa
2) Metode 'berisi' harus cepat, karena biasanya berjalan beberapa kali.
3) Ruang tidak terbatas (umum untuk solusi biasa)

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

Beberapa perpustakaan telah disebutkan di sini, tetapi saya merindukan perpustakaan yang sebenarnya saya cari: Spring!

Ada ObjectUtils # containConstant yang tidak sensitif huruf secara default, tetapi bisa ketat jika Anda mau. Digunakan seperti ini:

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

Catatan: Saya menggunakan metode kelebihan beban di sini untuk menunjukkan cara menggunakan pemeriksaan case sensitif. Anda dapat menghilangkan boolean untuk memiliki perilaku case-sensitive.

Berhati-hatilah dengan enum besar, karena mereka tidak menggunakan implementasi Peta seperti yang dilakukan beberapa ...

Sebagai bonus, ia juga menyediakan varian case-sensitive dari valueOf: ObjectUtils # caseInsensitiveValueOf

Anda bisa menggunakan ini

YourEnum {A1, A2, B1, B2}

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

Pembaruan disarankan oleh @ wightwulf1944 dimasukkan untuk membuat solusi lebih efisien.

Saya tidak berpikir ada, tetapi Anda dapat melakukan sesuatu seperti ini:

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

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

Edit:

Silakan lihat versi Richard tentang ini karena lebih tepat karena ini tidak akan berfungsi kecuali jika Anda mengonversinya untuk menggunakan Strings, yang dilakukan Richards.

Java Streaming menyediakan cara yang elegan untuk melakukan itu

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

Pengembalian: true jika ada elemen aliran yang cocok dengan nilai yang diberikan, jika tidak salah

Mengapa tidak menggabungkan balasan Pablo dengan 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;
        }
}

Pendekatan ini dapat digunakan untuk memeriksa Enum, Anda dapat menambahkannya ke Utilskelas:

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

Gunakan seperti ini:

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

Saya membuat kelas berikutnya untuk validasi ini

public class EnumUtils {

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

}

contoh penggunaan:

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

Anda dapat menggunakan valueOf("a1")jika Anda ingin mencari dengan menggunakan String

Ini adalah enum, itu adalah nilai konstan jadi jika dalam pernyataan switch hanya melakukan sesuatu seperti ini:

case: val1
case: val2

Juga mengapa Anda perlu tahu apa yang dinyatakan sebagai konstanta?

Dengan jambu bahkan lebih sederhana:

boolean isPartOfMyEnum(String myString){

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

}

Ini menggabungkan semua pendekatan dari metode sebelumnya dan harus memiliki kinerja yang setara. Ini dapat digunakan untuk enum apa pun, menguraikan solusi "Edit" dari @Richard H, dan menggunakan Pengecualian untuk nilai yang tidak valid seperti @bestsss. Satu-satunya tradeoff adalah bahwa kelas perlu ditentukan, tetapi yang mengubah ini menjadi dua baris.

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

solusi untuk memeriksa apakah nilai hadir dan dapatkan nilai enum sebagai imbalan:

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

Yang ini bekerja untuk saya:

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

Jika Anda Menggunakan Java 8 atau lebih baru, Anda bisa melakukan ini:

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

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

Anda dapat menjadikannya sebagai metode berisi:

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

atau Anda bisa menggunakannya dengan blok kode Anda:

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

Anda juga dapat menggunakan: com.google.common.base.Enums

Enums.getIfPresent (varEnum.class, varToLookFor) mengembalikan Opsional

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

Saya hanya akan menulis,

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

Enum # sama dengan hanya berfungsi dengan membandingkan objek.

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

enumcukup kuat di Jawa. Anda dapat dengan mudah menambahkan containsmetode ke enum Anda (seperti Anda akan menambahkan metode ke kelas):

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

};