Converter do tipo enum ordinal para enum

Eu tenho o tipo de enum ReportTypeEnumque é passado entre métodos em todas as minhas classes, mas preciso passar isso na URL para usar o método ordinal para obter o valor int. Depois de obtê-lo em minha outra página JSP, preciso convertê-lo em volta para um ReportTypeEnumpara que eu possa continuar passando.

Como posso converter ordinal para o ReportTypeEnum?

Usando o Java 6 SE.

Para converter um ordinal em sua representação enum, convém fazer o seguinte:

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

Observe os limites da matriz.

Observe que toda chamada para values()retorna um array clonado recentemente que pode afetar o desempenho de maneira negativa. Você pode querer armazenar em cache a matriz se ela for chamada com frequência.

Exemplo de código sobre como fazer cachevalues() .

_{Esta resposta foi editada para incluir o feedback fornecido dentro dos comentários}

Esta é quase certamente uma má ideia . Certamente, se o ordinal é de fato persistido (por exemplo, porque alguém marcou o URL como favorito) - isso significa que você deve sempre preservar a enumordem no futuro, o que pode não ser óbvio para os mantenedores de código na linha.

Por que não codificar o enumuso myEnumValue.name()(e decodificar via ReportTypeEnum.valueOf(s))?

Se eu vou usar values()muito:

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

Enquanto isso, where.java:

Suit suit = Suit.values[ordinal];

Mente seus limites de matriz.

Concordo com a maioria das pessoas que usar ordinal é provavelmente uma má ideia. Normalmente, resolvo esse problema fornecendo ao enum um construtor privado que pode usar, por exemplo, um valor de banco de dados e criar uma fromDbValuefunção estática semelhante à da resposta 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;
    }

}

Agora você pode alterar a ordem sem alterar a pesquisa e vice-versa.

Você pode usar uma tabela de pesquisa 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);
  }
}

É isso que eu uso. Não pretendo que seja muito menos "eficiente" do que as soluções mais simples acima. O que ele faz é fornecer uma mensagem de exceção muito mais clara que "ArrayIndexOutOfBounds" quando um valor ordinal inválido é usado na solução acima.

Ele utiliza o fato de que o javadoc EnumSet especifica o iterador retorna os elementos em sua ordem natural. Há uma afirmação se isso não estiver correto.

O teste JUnit4 demonstra como é usado.

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

Isto é o que eu faço no Android com 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];
    }
}

é curto e não preciso me preocupar em ter uma exceção no Proguard

Você pode definir um método simples como:

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

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

E use-o 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];
  }
}

a classe de teste

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

Compreendo que você compartilhe conosco se tiver um código mais eficiente. Meu enum é enorme e é constantemente chamado milhares de vezes.

Portanto, uma maneira de fazer o ExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];que funciona e é fácil, no entanto, como mencionado anteriormente, ExampleEnum.values()retorna um novo array clonado para cada chamada. Isso pode ser desnecessariamente caro. Podemos resolver isso armazenando em cache a matriz dessa maneira ExampleEnum[] values = values(). Também é "perigoso" permitir que nossa matriz em cache seja modificada. Alguém poderia escrever ExampleEnum.values[0] = ExampleEnum.type2;Então, eu o tornaria privado com um método acessador que não faça cópias extras.

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

Você usaria ExampleEnum.value(ordinal)para obter o valor de enum associado aordinal

Cada enumeração tem nome (), que fornece uma sequência com o nome do membro da enumeração.

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

Toda enumeração tem um valueOf() método, que usa um tipo de enum e uma string, para executar a operação reversa:

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

Por que alguém usaria ordinais está além de mim. Pode ser em nanossegundos mais rápido, mas não é seguro, se os membros da enum mudarem, pois outro desenvolvedor pode não estar ciente de que algum código depende de valores ordinais (especialmente na página JSP citada na pergunta, a sobrecarga da rede e do banco de dados domina completamente o time, sem usar um número inteiro sobre uma string).