Bagaimana saya bisa mencari Java enum dari nilai String-nya?

Saya ingin mencari enum dari nilai stringnya (atau mungkin nilai lainnya). Saya sudah mencoba kode berikut tetapi tidak mengizinkan statis di inisialisasi. Apakah ada cara sederhana?

public enum Verbosity {

    BRIEF, NORMAL, FULL;

    private static Map<String, Verbosity> stringMap = new HashMap<String, Verbosity>();

    private Verbosity() {
        stringMap.put(this.toString(), this);
    }

    public static Verbosity getVerbosity(String key) {
        return stringMap.get(key);
    }
};

Gunakan valueOfmetode yang secara otomatis dibuat untuk setiap Enum.

Verbosity.valueOf("BRIEF") == Verbosity.BRIEF

Untuk nilai arbitrer, mulailah dengan:

public static Verbosity findByAbbr(String abbr){
    for(Verbosity v : values()){
        if( v.abbr().equals(abbr)){
            return v;
        }
    }
    return null;
}

Hanya pindah nanti ke implementasi Peta jika profiler Anda memberi tahu Anda.

Saya tahu ini mengulangi semua nilai, tetapi dengan hanya 3 nilai enum, hampir tidak layak dilakukan dengan upaya lain, pada kenyataannya kecuali jika Anda memiliki banyak nilai, saya tidak akan repot dengan Peta, itu akan cukup cepat.

Anda sudah dekat. Untuk nilai arbitrer, coba sesuatu seperti berikut ini:

public enum Day { 

    MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"),
    THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ;

    private final String abbreviation;

    // Reverse-lookup map for getting a day from an abbreviation
    private static final Map<String, Day> lookup = new HashMap<String, Day>();

    static {
        for (Day d : Day.values()) {
            lookup.put(d.getAbbreviation(), d);
        }
    }

    private Day(String abbreviation) {
        this.abbreviation = abbreviation;
    }

    public String getAbbreviation() {
        return abbreviation;
    }

    public static Day get(String abbreviation) {
        return lookup.get(abbreviation);
    }
}

dengan Java 8 Anda dapat mencapai dengan cara ini:

public static Verbosity findByAbbr(final String abbr){
    return Arrays.stream(values()).filter(value -> value.abbr().equals(abbr)).findFirst().orElse(null);
}

Jawaban @ Lyle agak berbahaya dan saya telah melihatnya tidak bekerja terutama jika Anda membuat enum kelas dalam statis. Sebaliknya saya telah menggunakan sesuatu seperti ini yang akan memuat peta BootstrapSingleton sebelum enum.

Sunting ini seharusnya tidak menjadi masalah lagi dengan JVM modern (JVM 1.6 atau lebih tinggi) tapi saya pikir masih ada masalah dengan JRebel tapi saya belum punya kesempatan untuk menguji ulang .

Muat saya terlebih dahulu:

   public final class BootstrapSingleton {

        // Reverse-lookup map for getting a day from an abbreviation
        public static final Map<String, Day> lookup = new HashMap<String, Day>();
   }

Sekarang muat di enum constructor:

   public enum Day { 
        MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"),
        THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ;

        private final String abbreviation;

        private Day(String abbreviation) {
            this.abbreviation = abbreviation;
            BootstrapSingleton.lookup.put(abbreviation, this);
        }

        public String getAbbreviation() {
            return abbreviation;
        }

        public static Day get(String abbreviation) {
            return lookup.get(abbreviation);
        }
    }

Jika Anda memiliki enum bagian dalam, Anda bisa mendefinisikan Peta di atas definisi enum dan bahwa (secara teori) harus dimuat sebelumnya.

Dan Anda tidak dapat menggunakan valueOf () ?

Sunting: Btw, tidak ada yang menghentikan Anda menggunakan statis {} dalam enum.

Jika itu membantu orang lain, opsi yang saya pilih, yang tidak tercantum di sini, menggunakan fungsionalitas Peta Guava :

public enum Vebosity {
    BRIEF("BRIEF"),
    NORMAL("NORMAL"),
    FULL("FULL");

    private String value;
    private Verbosity(final String value) {
        this.value = value;
    }

    public String getValue() {
        return this.value;
    }

    private static ImmutableMap<String, Verbosity> reverseLookup = 
            Maps.uniqueIndex(Arrays.asList(Verbosity.values()), Verbosity::getValue);

    public static Verbosity fromString(final String id) {
        return reverseLookup.getOrDefault(id, NORMAL);
    }
}

Dengan default yang dapat Anda gunakan null, Anda dapat throw IllegalArgumentExceptionatau Anda fromStringdapat mengembalikan Optional, perilaku apa pun yang Anda inginkan.

karena java 8 Anda dapat menginisialisasi peta dalam satu baris dan tanpa blok statis

private static Map<String, Verbosity> stringMap = Arrays.stream(values())
                 .collect(Collectors.toMap(Enum::toString, Function.identity()));

Mungkin, lihat ini. Ini bekerja untuk saya. Tujuan dari ini adalah untuk mencari 'RED' dengan '/ red_color'. Mendeklarasikan static mapdan memuat enums ke dalamnya hanya sekali akan membawa beberapa manfaat kinerja jika enumjumlahnya banyak.

public class Mapper {

public enum Maps {

    COLOR_RED("/red_color", "RED");

    private final String code;
    private final String description;
    private static Map<String, String> mMap;

    private Maps(String code, String description) {
        this.code = code;
        this.description = description;
    }

    public String getCode() {
        return name();
    }

    public String getDescription() {
        return description;
    }

    public String getName() {
        return name();
    }

    public static String getColorName(String uri) {
        if (mMap == null) {
            initializeMapping();
        }
        if (mMap.containsKey(uri)) {
            return mMap.get(uri);
        }
        return null;
    }

    private static void initializeMapping() {
        mMap = new HashMap<String, String>();
        for (Maps s : Maps.values()) {
            mMap.put(s.code, s.description);
        }
    }
}
}

Silakan masukkan opini Anda.

Anda dapat mendefinisikan Enum sebagai kode berikut:

public enum Verbosity 
{
   BRIEF, NORMAL, FULL, ACTION_NOT_VALID;
   private int value;

   public int getValue()
   {
     return this.value;
   } 

   public static final Verbosity getVerbosityByValue(int value)
   {
     for(Verbosity verbosity : Verbosity.values())
     {
        if(verbosity.getValue() == value)
            return verbosity ;
     }

     return ACTION_NOT_VALID;
   }

   @Override
   public String toString()
   {
      return ((Integer)this.getValue()).toString();
   }
};

Lihat tautan berikut untuk klarifikasi lebih lanjut

Jika Anda menginginkan nilai default dan tidak ingin membangun peta pencarian, Anda bisa membuat metode statis untuk mengatasinya. Contoh ini juga menangani pencarian di mana nama yang diharapkan akan dimulai dengan angka.

    public static final Verbosity lookup(String name) {
        return lookup(name, null);
    }

    public static final Verbosity lookup(String name, Verbosity dflt) {
        if (StringUtils.isBlank(name)) {
            return dflt;
        }
        if (name.matches("^\\d.*")) {
            name = "_"+name;
        }
        try {
            return Verbosity.valueOf(name);
        } catch (IllegalArgumentException e) {
            return dflt;
        }
    }

Jika Anda membutuhkannya pada nilai sekunder, Anda hanya perlu membuat peta pencarian terlebih dahulu seperti pada beberapa jawaban lainnya.

public enum EnumRole {

ROLE_ANONYMOUS_USER_ROLE ("anonymous user role"),
ROLE_INTERNAL ("internal role");

private String roleName;

public String getRoleName() {
    return roleName;
}

EnumRole(String roleName) {
    this.roleName = roleName;
}

public static final EnumRole getByValue(String value){
    return Arrays.stream(EnumRole.values()).filter(enumRole -> enumRole.roleName.equals(value)).findFirst().orElse(ROLE_ANONYMOUS_USER_ROLE);
}

public static void main(String[] args) {
    System.out.println(getByValue("internal role").roleName);
}

}

Anda dapat menggunakan Enum::valueOf()fungsi seperti yang disarankan oleh Gareth Davis & Brad Mace di atas, tetapi pastikan Anda menangani IllegalArgumentExceptionyang akan dibuang jika string yang digunakan tidak ada di enum.