Convertir de enum ordinal a enum type

Tengo el tipo de enumeración ReportTypeEnumque se pasa entre los métodos en todas mis clases, pero luego necesito pasar esto en la URL, así que uso el método ordinal para obtener el valor int. Después de obtenerlo en mi otra página JSP, necesito convertirlo de nuevo a un ReportTypeEnumpara poder continuar pasándolo.

¿Cómo puedo convertir ordinal a la ReportTypeEnum?

Usando Java 6 SE.

Para convertir un ordinal en su representación enum, es posible que desee hacer esto:

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

Tenga en cuenta los límites de la matriz.

Tenga en cuenta que cada llamada a values()devuelve una matriz recién clonada que podría afectar el rendimiento de manera negativa. Es posible que desee almacenar en caché la matriz si se va a llamar con frecuencia.

Ejemplo de código sobre cómo almacenar en cachévalues() .

_{Esta respuesta fue editada para incluir la retroalimentación dada dentro de los comentarios}

Es casi seguro que sea una mala idea . Ciertamente, si el ordinal es de facto persistente (por ejemplo, porque alguien ha marcado la URL), significa que siempre debe preservar el enumorden en el futuro, lo que puede no ser obvio para los mantenedores de código en el futuro.

¿Por qué no codificar el enumuso myEnumValue.name()(y decodificar mediante ReportTypeEnum.valueOf(s)) en su lugar?

Si voy a usar values()mucho:

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

Mientras tanto donde sea.java:

Suit suit = Suit.values[ordinal];

Cuida los límites de tu matriz.

Estoy de acuerdo con la mayoría de las personas en que usar ordinal es probablemente una mala idea. Por lo general, resuelvo este problema dándole a la enumeración un constructor privado que puede tomar, por ejemplo, un valor DB y luego crear una fromDbValuefunción estática similar a la de la respuesta 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;
    }

}

Ahora puede cambiar el orden sin cambiar la búsqueda y viceversa.

Usted podría utilizar una tabla de consulta estática:

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

Esto es lo que yo uso. No pretendo que sea mucho menos "eficiente" que las soluciones más simples anteriores. Lo que hace es proporcionar un mensaje de excepción mucho más claro que "ArrayIndexOutOfBounds" cuando se utiliza un valor ordinal no válido en la solución anterior.

Utiliza el hecho de que EnumSet javadoc especifica que el iterador devuelve elementos en su orden natural. Hay una afirmación si eso no es correcto.

La prueba JUnit4 demuestra cómo se usa.

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

Esto es lo que hago en 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];
    }
}

es breve y no necesito preocuparme por tener una excepción en Proguard

Puede definir un método simple como:

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

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

Y úsalo como:

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 clase de prueba

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

Le agradezco que comparta con nosotros si tiene un código más eficiente. Mi enumeración es enorme y se llama constantemente miles de veces.

Entonces, una forma es hacer lo ExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];que funciona y es fácil, sin embargo, como se mencionó anteriormente, ExampleEnum.values()devuelve una nueva matriz clonada para cada llamada. Eso puede ser innecesariamente costoso. Podemos resolver eso almacenando en caché la matriz de esta manera ExampleEnum[] values = values(). También es "peligroso" permitir que se modifique nuestra matriz en caché. Alguien podría escribir, ExampleEnum.values[0] = ExampleEnum.type2;así que lo haría privado con un método de acceso que no haga copias adicionales.

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

Utilizaría ExampleEnum.value(ordinal)para obtener el valor de enumeración asociado conordinal

Cada enumeración tiene nombre (), que proporciona una cadena con el nombre del miembro enumeración.

Dado enum Suit{Heart, Spade, Club, Diamond}, Suit.Heart.name()daráHeart .

Cada enumeración tiene un valueOf()método, que toma un tipo de enumeración y una cadena, para realizar la operación inversa:

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

Por qué alguien usaría ordinales está más allá de mí. Puede ser nanosegundos más rápido, pero no es seguro, si los miembros de la enumeración cambian, ya que otro desarrollador puede no ser consciente de que algún código se basa en valores ordinales (especialmente en la página JSP citada en la pregunta, la sobrecarga de la red y la base de datos domina por completo el tiempo, no usar un entero sobre una cadena).