Conversion de l'énumération ordinale en type énumération

J'ai le type d'énumération ReportTypeEnum qui est transmis entre les méthodes dans toutes mes classes, mais je dois ensuite le passer sur l'URL, donc j'utilise la méthode ordinale pour obtenir la valeur int. Après l'avoir obtenu dans mon autre page JSP, je dois le reconvertir en un ReportTypeEnumafin de pouvoir continuer à le transmettre.

Comment puis-je convertir l'ordinal en ReportTypeEnum ?

Utilisation de Java 6 SE.

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()renvoie un tableau nouvellement cloné, ce qui peut avoir un impact négatif sur les performances. Vous souhaiterez peut-être mettre en cache le tableau s'il doit être appelé souvent.

Exemple de code sur la façon de mettre en cachevalues() .

_{Cette réponse a été modifiée pour inclure les commentaires fournis dans les commentaires}

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

Pourquoi ne pas encoder l' enumutilisation myEnumValue.name()(et décoder via ReportTypeEnum.valueOf(s)) à la place?

Si je vais utiliser values()beaucoup:

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

Pendant ce temps où.java:

Suit suit = Suit.values[ordinal];

Faites attention aux limites de votre tableau.

Je suis d'accord avec la plupart des gens que l'utilisation de l'ordinal est probablement une mauvaise idée. Je résout 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 une fromDbValuefonction statique 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 maintenant modifier l'ordre sans modifier la recherche et vice versa.

Vous pouvez utiliser une table de recherche 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);
  }
}

C'est ce que j'utilise. Je ne prétends pas que c'est beaucoup moins "efficace" que les solutions plus simples ci-dessus. Ce qu'il fait est de fournir un message d'exception beaucoup plus clair que "ArrayIndexOutOfBounds" lorsqu'une valeur ordinale non valide est utilisée dans la solution ci-dessus.

Il utilise le fait que javadoc EnumSet spécifie que l'itérateur renvoie les éléments dans leur ordre naturel. Il y a une affirmation si ce n'est pas correct.

Le test JUnit4 montre comment il est utilisé.

 /**
 * convert ordinal to Enum
 * @param clzz may not be null
 * @param ordinal
 * @return e with e.ordinal( ) == ordinal
 * @throws IllegalArgumentException if ordinal out of range
 */
public static <E extends Enum<E> > E lookupEnum(Class<E> clzz, int ordinal) {
    EnumSet<E> set = EnumSet.allOf(clzz);
    if (ordinal < set.size()) {
        Iterator<E> iter = set.iterator();
        for (int i = 0; i < ordinal; i++) {
            iter.next();
        }
        E rval = iter.next();
        assert(rval.ordinal() == ordinal);
        return rval;
    }
    throw new IllegalArgumentException("Invalid value " + ordinal + " for " + clzz.getName( ) + ", must be < " + set.size());
}

@Test
public void lookupTest( ) {
    java.util.concurrent.TimeUnit tu = lookupEnum(TimeUnit.class, 3);
    System.out.println(tu);
}

Voici ce que je fais sur Android avec Proguard:

public enum SomeStatus {
    UNINITIALIZED, STATUS_1, RESERVED_1, STATUS_2, RESERVED_2, STATUS_3;//do not change order

    private static SomeStatus[] values = null;
    public static SomeStatus fromInteger(int i) {
        if(SomeStatus.values == null) {
            SomeStatus.values = SomeStatus.values();
        }
        if (i < 0) return SomeStatus.values[0];
        if (i >= SomeStatus.values.length) return SomeStatus.values[0];
        return SomeStatus.values[i];
    }
}

c'est court et je n'ai pas besoin de m'inquiéter d'avoir une exception dans Proguard

Vous pouvez définir une méthode simple comme:

public enum Alphabet{
    A,B,C,D;

    public static Alphabet get(int index){
        return Alphabet.values()[index];
    }
}

Et utilisez-le comme:

System.out.println(Alphabet.get(2));

public enum Suit implements java.io.Serializable, Comparable<Suit>{
  spades, hearts, diamonds, clubs;
  private static final Suit [] lookup  = Suit.values();
  public Suit fromOrdinal(int ordinal) {
    if(ordinal< 1 || ordinal> 3) return null;
    return lookup[value-1];
  }
}

la classe de test

public class MainTest {
    public static void main(String[] args) {
        Suit d3 = Suit.diamonds;
        Suit d3Test = Suit.fromOrdinal(2);
        if(d3.equals(d3Test)){
            System.out.println("Susses");
        }else System.out.println("Fails");
    }
}

J'apprécie que vous partagiez avec nous si vous avez un code plus efficace, mon énumération est énorme et constamment appelée des milliers de fois.

Donc, une façon est de faire ExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];ce qui fonctionne et c'est facile, cependant, comme mentionné précédemment, ExampleEnum.values()retourne un nouveau tableau cloné pour chaque appel. Cela peut être inutilement coûteux. Nous pouvons résoudre ce problème en mettant le tableau en cache de cette façon ExampleEnum[] values = values(). Il est également "dangereux" de permettre à notre tableau mis en cache d'être modifié. Quelqu'un pourrait écrire ExampleEnum.values[0] = ExampleEnum.type2;Donc je le rendrais privé avec une méthode d'accesseur qui ne fait pas de copie supplémentaire.

private enum ExampleEnum{
    type0, type1, type2, type3;
    private static final ExampleEnum[] values = values();
    public static ExampleEnum value(int ord) {
        return values[ord];
    }
}

Vous utiliseriez ExampleEnum.value(ordinal)pour obtenir la valeur d'énumération associée àordinal

Chaque enum a un nom (), qui donne une chaîne avec le nom du membre enum.

Étant donné enum Suit{Heart, Spade, Club, Diamond}, Suit.Heart.name()donneraHeart .

Chaque énumération a un valueOf() méthode, qui prend un type d'énumération et une chaîne, pour effectuer l'opération inverse:

Enum.valueOf(Suit.class, "Heart")retourne Suit.Heart.

Pourquoi quelqu'un utiliserait des ordinaux me dépasse. Cela peut être plus rapide de nanosecondes, mais ce n'est pas sûr, si les membres de l'énumération changent, car un autre développeur peut ne pas être au courant qu'un code s'appuie sur des valeurs ordinales (en particulier dans la page JSP citée dans la question, la surcharge du réseau et de la base de données domine complètement le temps, sans utiliser un entier sur une chaîne).