Discussion :

[onlytoine]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[JoloKossovar]

Pourquoi ne fais tu pas une map static ?

[onlytoine]

dans l'énum ?

[JoloKossovar]

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

[adiGuba]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
	public enum OperatorType {
		OPEN, CLOSE, MULTIPLICATION;
 
		public static OperatorType getByOrdinal(int ordinal) {
			return OperatorType.values()[ordinal];
		}
	}

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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++

[onlytoine]

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

voilà une solution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[JoloKossovar]

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

[onlytoine]

je ne connaissais pas ordinal non plus...

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[adiGuba]

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++

[adiGuba]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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++

[onlytoine]

je vais tester tout ça, merci pour vos tuyaux