Jak wyszukać wyliczenie Java na podstawie jego wartości ciągu?

Chciałbym wyszukać wyliczenie na podstawie jego wartości ciągu (lub ewentualnie dowolnej innej wartości). Wypróbowałem następujący kod, ale nie zezwala on na statyczne w inicjatorach. Czy istnieje prosty sposób?

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

Użyj valueOfmetody, która jest tworzona automatycznie dla każdego Enum.

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

Dla dowolnych wartości zacznij od:

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

Przejdź później do implementacji mapy tylko wtedy, gdy Twój profiler Ci to zaleci.

Wiem, że iteruje po wszystkich wartościach, ale przy tylko 3 wartościach wyliczeniowych nie jest to warte żadnego innego wysiłku, w rzeczywistości, jeśli nie masz wielu wartości, nie zawracałbym sobie głowy mapą, będzie wystarczająco szybko.

Jesteś blisko. W przypadku dowolnych wartości spróbuj czegoś takiego:

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

z Javą 8 możesz osiągnąć w ten sposób:

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

Odpowiedź @ Lyle jest raczej niebezpieczna i widziałem, że nie działa, szczególnie jeśli uczynisz enum statyczną klasą wewnętrzną. Zamiast tego użyłem czegoś takiego, który załaduje mapy BootstrapSingleton przed wyliczeniami.

Edycja tego nie powinna już stanowić problemu w przypadku nowoczesnych maszyn JVM (JVM 1.6 lub nowszych), ale myślę, że nadal występują problemy z JRebel, ale nie miałem okazji go ponownie przetestować .

Załaduj mnie najpierw:

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

Teraz załaduj go do konstruktora wyliczenia:

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

Jeśli masz wewnętrzne wyliczenie, możesz po prostu zdefiniować Mapę powyżej definicji wyliczenia i to (teoretycznie) powinno zostać załadowane wcześniej.

I nie możesz użyć valueOf () ?

Edycja: przy okazji, nic nie stoi na przeszkodzie, abyś używał static {} w wyliczeniu.

W przypadku, gdy pomaga to innym, preferowana przeze mnie opcja, której tutaj nie ma, wykorzystuje funkcjonalność map Guavy :

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

Z domyślnym ustawieniem, którego możesz użyć null, możesz throw IllegalArgumentExceptionlub możesz fromStringzwrócić Optionaldowolne zachowanie.

od wersji Java 8 możesz zainicjować mapę w jednej linii i bez statycznego bloku

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

Może spójrz na to. To działa dla mnie. Celem tego jest wyszukanie „RED” za pomocą „/ red_color”. Zadeklarowanie a static mapi załadowanie do niego enums tylko raz przyniosłoby pewne korzyści w zakresie wydajności, jeśli enumjest ich wiele.

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

Prosimy o wyrażenie opinii.

Możesz zdefiniować swój Enum jako następujący kod:

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

Zobacz poniższy link, aby uzyskać więcej wyjaśnień

Jeśli chcesz mieć wartość domyślną i nie chcesz tworzyć map wyszukiwania, możesz utworzyć statyczną metodę do obsługi tego. Ten przykład obsługuje również wyszukiwania, w których oczekiwana nazwa zaczynałaby się od liczby.

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

Jeśli potrzebujesz go na wartości drugorzędnej, najpierw zbuduj mapę wyszukiwania, tak jak w niektórych innych odpowiedziach.

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

}

Możesz użyć Enum::valueOf()funkcji zgodnie z sugestią Garetha Davisa i Brada Mace'a powyżej, ale upewnij się, że obsłużysz to IllegalArgumentException, co zostanie wyrzucone, jeśli użyty ciąg nie jest obecny w wyliczeniu.