Comment rechercher une énumération Java à partir de sa valeur String?

Je voudrais rechercher une énumération à partir de sa valeur de chaîne (ou éventuellement de toute autre valeur). J'ai essayé le code suivant mais il n'autorise pas la statique dans les initialiseurs. Y a-t-il un moyen simple?

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

Utilisez la valueOfméthode qui est automatiquement créée pour chaque Enum.

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

Pour les valeurs arbitraires, commencez par:

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

Ne passez à l'implémentation de Map que si votre profileur vous le demande.

Je sais que cela itère sur toutes les valeurs, mais avec seulement 3 valeurs d'énumération, cela ne vaut guère aucun autre effort, en fait à moins que vous n'ayez beaucoup de valeurs, je ne me soucierais pas d'une carte, ce sera assez rapide.

Tu es proche. Pour les valeurs arbitraires, essayez quelque chose comme ce qui suit:

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

avec Java 8, vous pouvez réaliser de cette manière:

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

La réponse de @ Lyle est plutôt dangereuse et je l'ai vu ne pas fonctionner en particulier si vous faites de l'énumération une classe interne statique. Au lieu de cela, j'ai utilisé quelque chose comme celui-ci qui chargera les cartes BootstrapSingleton avant les énumérations.

Modifier cela ne devrait plus être un problème avec les JVM modernes (JVM 1.6 ou supérieur) mais je pense qu'il y a encore des problèmes avec JRebel mais je n'ai pas eu l'occasion de le tester à nouveau .

Chargez-moi d'abord:

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

Maintenant, chargez-le dans le constructeur enum:

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

Si vous avez une énumération interne, vous pouvez simplement définir la carte au-dessus de la définition d'énumération et cela (en théorie) devrait être chargé avant.

Et vous ne pouvez pas utiliser valueOf () ?

Edit: Btw, rien ne vous empêche d'utiliser static {} dans une énumération.

Au cas où cela aiderait les autres, l'option que je préfère, qui n'est pas répertoriée ici, utilise la fonctionnalité Cartes de 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);
    }
}

Avec la valeur par défaut, vous pouvez utiliser null, vous pouvez throw IllegalArgumentExceptionou vous fromStringpouvez retourner un Optionalcomportement, quel que soit le comportement que vous préférez.

depuis java 8 vous pouvez initialiser la carte en une seule ligne et sans bloc statique

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

Peut-être, jetez un œil à ceci. Cela fonctionne pour moi. Le but de ceci est de rechercher 'RED' avec '/ red_color'. Déclarer a static mapet ne charger le enums qu'une seule fois apporterait des avantages en termes de performances si les enums sont nombreux.

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

Veuillez donner votre avis.

Vous pouvez définir votre Enum comme le code suivant:

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

Voir le lien suivant pour plus de précisions

Si vous voulez une valeur par défaut et ne voulez pas créer de mappes de recherche, vous pouvez créer une méthode statique pour gérer cela. Cet exemple gère également les recherches où le nom attendu commencerait par un nombre.

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

Si vous en avez besoin sur une valeur secondaire, vous devez simplement créer la carte de recherche en premier, comme dans certaines des autres réponses.

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

}

Vous pouvez utiliser la Enum::valueOf()fonction comme suggéré par Gareth Davis & Brad Mace ci-dessus, mais assurez-vous de gérer le IllegalArgumentExceptionqui serait lancé si la chaîne utilisée n'est pas présente dans l'énumération.