Conversion de l'ordinal d'un enum en type d'enum

Question

J'ai le type enum ReportTypeEnum qui sont transmises entre les méthodes dans toutes mes classes, mais je dois ensuite les transmettre à l'URL et j'utilise donc la méthode ordinal pour obtenir la valeur int. Après l'avoir récupérée dans mon autre page JSP, je dois la reconvertir en un fichier ReportTypeEnum pour que je puisse continuer à le faire passer.

Comment puis-je convertir l'ordinal en ReportTypeEnum ?

Utilisation de Java 6 SE.

Answer 1

Pour convertir un ordinal en sa représentation enum, vous pouvez procéder comme suit :

ReportTypeEnum value = ReportTypeEnum.values()[ordinal];

Veuillez noter les limites du tableau.

Notez que chaque appel à values() retourne un tableau nouvellement cloné qui peut avoir un impact négatif sur les performances. Vous voudrez peut-être mettre le tableau en cache s'il est appelé souvent.

Exemple de code pour la mise en cache values() .

---

_{Cette réponse a été modifiée afin d'inclure le feedback donné dans les commentaires.}

Answer 2

C'est presque certainement une mauvaise idée . Certes, si l'ordinal est de-facto persisté (par exemple parce que quelqu'un a mis l'URL en signet) - cela signifie que vous devez toujours conserver l'adresse de l'utilisateur. enum à l'avenir, ce qui peut ne pas être évident pour les responsables du code à l'avenir.

Pourquoi ne pas coder le enum en utilisant myEnumValue.name() (et décoder via ReportTypeEnum.valueOf(s) ) à la place ?

Answer 3

Si je dois utiliser values() beaucoup :

enum Suit {
   Hearts, Diamonds, Spades, Clubs;
   public static final Suit values[] = values();
}

Pendant ce temps, où que ce soit, java :

Suit suit = Suit.values[ordinal];

Si vous voulez que le tableau soit privé, je vous en prie :

private static final Suit values[] = values();
public static Suit get(int ordinal) { return values[ordinal]; }

...

Suit suit = Suit.get(ordinal);

Attention aux limites de votre tableau.

Answer 4

Je suis d'accord avec la plupart des gens pour dire que l'utilisation de l'ordinal est probablement une mauvaise idée. Je résous généralement ce problème en donnant à l'énumération un constructeur privé qui peut prendre par exemple une valeur DB, puis créer un fichier statique de l'énumération. fromDbValue similaire à celle de la réponse de Jan.

public enum ReportTypeEnum {
    R1(1),
    R2(2),
    R3(3),
    R4(4),
    R5(5),
    R6(6),
    R7(7),
    R8(8);

    private static Logger log = LoggerFactory.getLogger(ReportEnumType.class);  
    private static Map<Integer, ReportTypeEnum> lookup;
    private Integer dbValue;

    private ReportTypeEnum(Integer dbValue) {
        this.dbValue = dbValue;
    }

    static {
        try {
            ReportTypeEnum[] vals = ReportTypeEnum.values();
            lookup = new HashMap<Integer, ReportTypeEnum>(vals.length);

            for (ReportTypeEnum  rpt: vals)
                lookup.put(rpt.getDbValue(), rpt);
         }
         catch (Exception e) {
             // Careful, if any exception is thrown out of a static block, the class
             // won't be initialized
             log.error("Unexpected exception initializing " + ReportTypeEnum.class, e);
         }
    }

    public static ReportTypeEnum fromDbValue(Integer dbValue) {
        return lookup.get(dbValue);
    }

    public Integer getDbValue() {
        return this.dbValue;
    }

}

Vous pouvez désormais modifier l'ordre sans modifier la consultation et vice versa.

Answer 5

Vous pourrait utiliser une table de consultation statique :

public enum Suit {
  spades, hearts, diamonds, clubs;

  private static final Map<Integer, Suit> lookup = new HashMap<Integer, Suit>();

  static{
    int ordinal = 0;
    for (Suit suit : EnumSet.allOf(Suit.class)) {
      lookup.put(ordinal, suit);
      ordinal+= 1;
    }
  }

  public Suit fromOrdinal(int ordinal) {
    return lookup.get(ordinal);
  }
}