Converti da enum ordinal a enum type

Ho il tipo enum ReportTypeEnumche viene passato tra i metodi in tutte le mie classi, ma poi devo passare questo sull'URL, quindi uso il metodo ordinale per ottenere il valore int. Dopo averlo visualizzato nell'altra mia pagina JSP, devo convertirlo in un altro in ReportTypeEnummodo da poter continuare a passarlo.

Come posso convertire ordinale in ReportTypeEnum?

Utilizzo di Java 6 SE.

Per convertire un ordinale nella sua rappresentazione enum potresti voler fare questo:

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

Notare i limiti dell'array.

Si noti che ogni chiamata a values()restituisce un array appena clonato che potrebbe influire negativamente sulle prestazioni. È possibile che si desideri memorizzare nella cache l'array se verrà chiamato spesso.

Esempio di codice su come memorizzare nella cachevalues() .

_{Questa risposta è stata modificata per includere il feedback fornito all'interno dei commenti}

Questa è quasi certamente una cattiva idea . Certamente se l'ordinale è di fatto persistente (ad esempio perché qualcuno ha aggiunto l'URL ai segnalibri), significa che enumin futuro dovrai sempre conservare l' ordinamento, il che potrebbe non essere ovvio per i manutentori del codice lungo la linea.

Perché non codificare invece l' enumutilizzo myEnumValue.name()(e la decodifica tramite ReportTypeEnum.valueOf(s))?

Se userò values()molto:

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

Nel frattempo ovunque.java:

Suit suit = Suit.values[ordinal];

Fai attenzione ai limiti dell'array.

Sono d'accordo con la maggior parte delle persone sul fatto che usare ordinale sia probabilmente una cattiva idea. Solitamente risolvo questo problema dando all'enum un costruttore privato che può prendere ad esempio un valore DB e quindi creare una fromDbValuefunzione statica simile a quella nella risposta di 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;
    }

}

Ora puoi cambiare l'ordine senza cambiare la ricerca e viceversa.

È possibile utilizzare una tabella di ricerca statica:

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

Questo è quello che uso. Non pretendo che sia molto meno "efficiente" delle soluzioni più semplici di cui sopra. Ciò che fa è fornire un messaggio di eccezione molto più chiaro di "ArrayIndexOutOfBounds" quando nella soluzione precedente viene utilizzato un valore ordinale non valido.

Utilizza il fatto che EnumSet javadoc specifica che l'iteratore restituisce gli elementi nel loro ordine naturale. C'è un'asserzione se ciò non è corretto.

Il test JUnit4 dimostra come viene utilizzato.

 /**
 * 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);
}

Questo è quello che faccio su Android con 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];
    }
}

è breve e non devo preoccuparmi di avere un'eccezione in Proguard

Puoi definire un metodo semplice come:

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

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

E usalo come:

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

Apprezzo che condividi con noi se hai un codice più efficiente, il mio enum è enorme e costantemente chiamato migliaia di volte.

Quindi un modo è quello di fare ciò ExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];che funziona ed è facile, tuttavia, come accennato in precedenza, ExampleEnum.values()restituisce un nuovo array clonato per ogni chiamata. Questo può essere inutilmente costoso. Possiamo risolverlo memorizzando nella cache l'array in questo modo ExampleEnum[] values = values(). È anche "pericoloso" consentire la modifica del nostro array memorizzato nella cache. Qualcuno potrebbe scrivere, ExampleEnum.values[0] = ExampleEnum.type2;quindi lo renderei privato con un metodo di accesso che non esegue copie extra.

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

Dovresti usare ExampleEnum.value(ordinal)per ottenere il valore enum associatoordinal

Ogni enum ha name (), che fornisce una stringa con il nome del membro enum.

Dato enum Suit{Heart, Spade, Club, Diamond}, Suit.Heart.name()darà Heart.

Ogni enum ha un valueOf()metodo, che accetta un tipo di enum e una stringa, per eseguire l'operazione inversa:

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

Perché qualcuno userebbe gli ordinali è al di là di me. Potrebbe essere più veloce di nanosecondi, ma non è sicuro, se i membri dell'enum cambiano, poiché un altro sviluppatore potrebbe non essere a conoscenza del fatto che un codice si basa su valori ordinali (specialmente nella pagina JSP citata nella domanda, l'overhead della rete e del database domina completamente il tempo, non utilizzando un numero intero su una stringa).