Stocker des valeurs entières comme constantes de manière Enum en Java

Je crée actuellement des constantes entières de la manière suivante.

public class Constants { public static int SIGN_CREATE=0; public static int SIGN_CREATE=1; public static int HOME_SCREEN=2; public static int REGISTER_SCREEN=3; } 

Quand j’essaie de le faire de manière enum

 public enum PAGE{SIGN_CREATE,SIGN_CREATE,HOME_SCREEN,REGISTER_SCREEN} 

et quand j’ai utilisé PAGE.SIGN_CREATE il devrait retourner 1;

Eh bien, vous ne pouvez pas tout à fait le faire de cette façon. PAGE.SIGN_CREATE ne renverra jamais 1; il retournera PAGE.SIGN_CREATE . C’est le sharepoints types énumérés.

Cependant, si vous souhaitez append quelques touches, vous pouvez append des champs à vos énumérations, comme ceci:

 public enum PAGE{ SIGN_CREATE(0), SIGN_CREATE_BONUS(1), HOME_SCREEN(2), REGISTER_SCREEN(3); private final int value; PAGE(final int newValue) { value = newValue; } public int getValue() { return value; } } 

Et puis vous appelez PAGE.SIGN_CREATE.getValue() pour obtenir 0.

La raison la plus courante pour laquelle une constante entière associée à chaque valeur d’énumération est d’interopérer avec un autre composant qui attend toujours ces entiers (par exemple, un protocole de sérialisation que vous ne pouvez pas modifier ou les énumérations représentent des colonnes dans une table, etc.) .

Dans presque tous les cas, je suggère d’utiliser plutôt EnumMap . Il dissocie plus complètement les composants, si tel était le cas, ou si les énumérations représentent des index de colonnes ou quelque chose de similaire, vous pouvez facilement apporter des modifications ultérieurement (ou même au moment de l’exécution si nécessaire).

  private final EnumMap pageIndexes = new EnumMap(Page.class); pageIndexes.put(Page.SIGN_CREATE, 1); //etc., ... int createIndex = pageIndexes.get(Page.SIGN_CREATE); 

C’est aussi incroyablement efficace.

L’ajout de données de ce type à l’instance d’énumération même peut être très puissant, mais le plus souvent, il est abusé.

Edit: Je viens de me rendre compte que Bloch a abordé cette question dans Effective Java / 2nd edition, dans l’ article 33: Utiliser EnumMap au lieu de l’indexation ordinale .

Vous pouvez utiliser l’ ordinal . Donc, PAGE.SIGN_CREATE.ordinal() renvoie 1 .

MODIFIER:

Le seul problème avec cela est que si vous ajoutez, supprimez ou réorganisez les valeurs enum, vous allez briser le système. Pour beaucoup, ce n’est pas un problème car ils ne supprimeront pas les énumérations et n’appendont que des valeurs supplémentaires à la fin. Ce n’est pas pire que les constantes entières qui vous obligent également à ne pas les renuméroter. Cependant, il est préférable d’utiliser un système tel que:

 public enum PAGE{ SIGN_CREATE0(0), SIGN_CREATE(1) ,HOME_SCREEN(2), REGISTER_SCREEN(3) private int id; PAGE(int id){ this.id = id; } public int getID(){ return id; } } 

Vous pouvez alors utiliser getID . Donc, PAGE.SIGN_CREATE.getID() renvoie 1 .

Vous pouvez stocker cette valeur const dans l’énumération, comme cela. Mais pourquoi même utiliser le const? Est-ce que tu persévères la liste?

 public class SO3990319 { public static enum PAGE { SIGN_CREATE(1); private final int constValue; private PAGE(int constValue) { this.constValue = constValue; } public int constValue() { return constValue; } } public static void main(Ssortingng[] args) { System.out.println("Name: " + PAGE.SIGN_CREATE.name()); System.out.println("Ordinal: " + PAGE.SIGN_CREATE.ordinal()); System.out.println("Const: " + PAGE.SIGN_CREATE.constValue()); System.out.println("Enum: " + PAGE.valueOf("SIGN_CREATE")); } } 

Modifier:

Cela dépend de l’utilisation de l’int pour savoir si vous devez utiliser EnumMap ou un champ d’instance.

  • Bloch sur les champs d’instance Enum (Rubrique 31: Utiliser les champs d’instance au lieu des ordinaux)
  • Bloch sur EnumMap (Item 33: Utiliser EnumMap au lieu de l’indexation ordinale)

Si vous voulez être capable de convertir un integer en enum correspondant avec la valeur sélectionnée, voyez Constants.forValue(...) dans le code généré automatiquement ci-dessous mais sinon la réponse de BlairHippo est la meilleure façon de le faire.

 public enum Constants { SIGN_CREATE(0), SIGN_CREATE(1), HOME_SCREEN(2), REGISTER_SCREEN(3); public static final int SIZE = java.lang.Integer.SIZE; private int intValue; private static java.util.HashMap mappings; private static java.util.HashMap getMappings() { if (mappings == null) { synchronized (Constants.class) { if (mappings == null) { mappings = new java.util.HashMap(); } } } return mappings; } private Constants(int value) { intValue = value; getMappings().put(value, this); } public int getValue() { return intValue; } public static Constants forValue(int value) { return getMappings().get(value); } } 

J’ai trouvé cela utile:

http://dan.clarke.name/2011/07/enum-in-java-with-int-conversion/

 public enum Difficulty { EASY(0), MEDIUM(1), HARD(2); /** * Value for this difficulty */ public final int Value; private Difficulty(int value) { Value = value; } // Mapping difficulty to difficulty id private static final Map _map = new HashMap(); static { for (Difficulty difficulty : Difficulty.values()) _map.put(difficulty.Value, difficulty); } /** * Get difficulty from value * @param value Value * @return Difficulty */ public static Difficulty from(int value) { return _map.get(value); } }