Retrouver un énuméré "identifié"

Bonjour,

Quand on a une enumération "identifiée", comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public enum OperatorType { /**          * ( operator          */ OPEN(0), /**          * ) operator          */ CLOSE(1), /**          * Multiplication operator.          */ MULTIPLICATION(2),   ...

---

Ya t-il un moyen pour récupérer un élement de l'énum à partir de l'identifiant, sans écrire un gros switch/case:

Code:

---

1 2 3 4 5 6 7 8

public final static OperatorType fromId(int id) { switch (id) { case 0: return OPEN; case 1: return CLOSE; case 2: return MULTIPLICATION;

---

Car dans mon cas, j'ai énormément d'éléments et écrire le switch/case est facilement sujet à bogues !

Merci !

Toine

Pourquoi ne fais tu pas une map static ?

dans l'énum ?

Non tu remplace ton enum par une map static. Ca te permettra d'avoir tes couples (clé/valeur).

Salut,



Deux solutions : si tu n'as pas besoin d'ID spécifique autant utiliser l'ordre des enums : chaque éléments d'une enum est associé à une valeur entière accessible via la méthode ordinal(), et correspondant à son index dans la déclaration des éléments de l'enum.

Ainsi avec ce code :

Code:

---

1 2 3

public enum OperatorType { OPEN, CLOSE, MULTIPLICATION; }

---

OPEN.ordinal() vaut 0, CLOSE.ordinal() vaut 1, MULTIPLICATION.ordinal() vaut 2...

La valeur de l'ordinal correspond également à l'index des valeurs dans le tableau renvoyé par la méthode static values :

Code:

---

1 2 3

OperatorType type1 = OperatorType.values()[0]; // OPEN OperatorType type2 = OperatorType.values()[1]; // CLOSE OperatorType type3 = OperatorType.values()[2]; // MULTIPLICATION

---

Le plus propre étant bien sûr de se faire une méthode static d'accès :

Code:

---

1 2 3 4 5 6 7

public enum OperatorType { OPEN, CLOSE, MULTIPLICATION;   public static OperatorType getByOrdinal(int ordinal) { return OperatorType.values()[ordinal]; } }

---

:arrow: Attention toutefois cette solution ne peut marcher que si tu utilises un ordre normal (0, 1, 2, 3, ...) sans interruption ni saut. Si tu utilises d'autre identifiant numérique non ordonné de la sorte il faut gérer cela toi même !


En utilisant la méthode values() et une boucle de recherche cela pourrait faire l'affaire, par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public enum OperatorType { OPEN(0), CLOSE(10), MULTIPLICATION(100);     private final int id;   private OperatorType(int id) { this.id = id; }   public static OperatorType getByID(int id) { for (OperatorType type : OperatorType.values()) { if (type.id == id) return type; } throw new IllegalArgumentException(); } }

---

a++

j'ai vraiment besoin de l'énum...

voilà une solution :

Code:

---

1 2 3 4 5 6 7 8 9

public static void main(String[] args) { OperatorType[] all = OperatorType.values(); System.out.println("switch (id) {"); for (OperatorType idType : all) { System.out.println("case " + idType.value + ":"); System.out.println("return " + idType.name() + ";"); } System.out.println("} return null;"); }

---

:D

La méthode d'adiguba est la bonne alors ^^
D'ailleurs je ne connaissais pas ordinal().

je ne connaissais pas ordinal non plus...

en terme de performance, quelle est la meilleure solution, la mienne ou la tienne :

Code:

---

1 2 3 4 5 6 7

public static OperatorType getByID(int id) { for (OperatorType type : OperatorType.values()) { if (type.id == id) return type; } throw new IllegalArgumentException(); }

---

(effectivement, l'id n'est pas séquentiel dans mon cas)

Toine

Citation:

---

Envoyé par JoloKossovar

D'ailleurs je ne connaissais pas ordinal().

---

Les enums héritent de la classe Enum et possèdent donc les méthodes suivantes :

• ordinal() qui retourne l'index de la valeur courante, qui dépend de la déclaration dans l'enum et qui correspond à l'index du tableau renvoyé par values().
• name() qui retourne le nom de la valeur de l'enum tel qu'il est déclaré dans le source (c'est à dire le nom de la variable).

(sans oublier un grand nombre de méthode hérité de Object redéfini en final afin qu'elle ne "casse" pas les notions d'unicité introduite par les enums).


A cela s'ajoute deux méthode static :

• values() donc qui retourne toutes les valeurs de l'enum...
• valueOf(), qui permet de retrouver une valeur par son nom

Sans oublier que les enum implémente Comparable<E> et Serializable ;)


a++

Citation:

---

Envoyé par onlytoine

en terme de performance, quelle est la meilleure solution, la mienne ou la tienne :

---

Si j'ai bien compris la tienne consiste à gérer le code java du switch...
Cela doit être plus performant (et encore la différence ne doit être sensible que sur de très grosse enums), mais il ne faut pas oublier de régénérer le code à chaque modif ;)


Sinon tu peux toujours créer une Map static qui contiendra tous les champs :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public enum OperatorType { OPEN(0), CLOSE(10), MULTIPLICATION(100);   private final int id;   private OperatorType(int id) { this.id = id; }   private static final Map<Integer, OperatorType> MAP = new HashMap<Integer, OperatorType>(); static { for (OperatorType type : OperatorType.values()) { MAP.put(type.id, type); } }   public static OperatorType getByID(int id) { return MAP.get(id); } }

---

Mais encore une fois je ne sais pas si la différence est vraiment significative...

a++

je vais tester tout ça, merci pour vos tuyaux ;)