Convertire da enum ordinal a enum tipo

Question

Ho il tipo di enum ReportTypeEnum che viene passato tra i metodi in tutte le mie classi ma devo quindi passare questo sull'URL in modo da utilizzare il metodo ordinale per ottenere il valore int. Dopo averlo ottenuto nella mia altra pagina JSP, ho bisogno di convertirlo in un ReportTypeEnum così posso continuare a passarlo.

Come convertire l'ordinale in ReportTypeEnum?

Utilizzo di Java 6 SE.

Answer 1

Per convertire un numero ordinale nella sua represantation enum si potrebbe desiderare di fare questo:

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

Si prega di notare i limiti dell'array.

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

Code example on how to cache values().

---

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

Answer 2

Questo è quasi certamente una cattiva idea. Certamente se l'ordinale è di fatto persistente (ad esempio perché qualcuno ha aggiunto un segnalibro all'URL), significa che è necessario conservare sempre l'ordinamento enum in futuro, il che potrebbe non essere ovvio per codificare i manutentori lungo la linea.

Perché non codificare lo enum utilizzando myEnumValue.name() (e decodificare tramite ReportTypeEnum.valueOf(s))?

Answer 3

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

Answer 4

Ogni enum ha nome(), che dà una stringa con il nome di membro enum.

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

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

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

Perché chiunque userebbe gli ordinali è oltre me. Potrebbe essere più veloce di nanosecondi, ma non è sicuro, se i membri di enum cambiano, poiché un altro sviluppatore potrebbe non essere consapevole del fatto che alcuni codici si basano su valori ordinali (specialmente nella pagina JSP citata nella domanda, l'overhead di rete e database domina completamente il tempo, non usando un intero su una stringa).

Answer 5

Se ho intenzione di utilizzare values() un sacco:

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

Nel frattempo ovunque.java:

Suit suit = Suit.values[ordinal]; 

Mente i limiti dell'array.

Answer 6

Sono d'accordo con la maggior parte delle persone che usare l'ordinale è probabilmente una cattiva idea. Solitamente risolvo questo problema dando all'enumerazione un costruttore privato che può prendere ad esempio un valore di DB, quindi creare una funzione statica fromDbValue simile a quella nella risposta di Jan.

public 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 è possibile modificare l'ordine senza modificare la ricerca e viceversa.

Answer 7

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

Utilizza il fatto che EnumSet javadoc specifica l'iteratore restituisce gli elementi nel loro ordine naturale. C'è un assert se 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); 
} 

Answer 8

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

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

Mi rendo conto che voi condividete con noi se si dispone di un codice più efficiente, mio ​​enum è migliaia enormi e costantemente chiamati di volte.

Answer 9

Si supponga di avere il seguente enum:

public enum ErrorCodes { 
    BUSINESS_ERROR(100), SERVER_ERROR(500), NETWORK_ERROR(1000); 
} 

Per impostazione predefinita, non si sarebbe in grado di recuperare un CodiceErrore esempio dal suo valore numerico in quanto Java non fornisce alcun modo per recuperare Istanza Enum di un campo.

Per fare questo, normalmente esporre un hashmap statico all'interno della classe Enum che associa ciascun valore al suo esempio Enum corrispondente come segue:

public enum ErrorCodes { 
    BUSINESS_ERROR(100), SERVER_ERROR(500), NETWORK_ERROR(1000); 

    private int errorCode; 
    private static Map<Integer, ErrorCodes> errorCodeByErrorNumber = new HashMap<Integer, ErrorCodes>(); 

    static { 
     for (ErrorCodes errorCode : ErrorCodes.values()) { 
      errorCodeByErrorNumber.put(errorCode.getErrorCode(), errorCode); 
     } 
    } 

    private ErrorCodes(int errorCode) { 
     this.errorCode = errorCode; 
    } 

    public int getErrorCode() { 
     return errorCode; 
    } 

    public static ErrorCodes getErrorCodeByNumber(Integer errorNumber) { 
     return errorCodeByErrorNumber.get(errorNumber); 
    } 
} 

Per operazioni più comuni Enum, controllare questo: How to use Enums in java