Konversi dari tipe enum ordinal ke enum

Saya memiliki tipe enum ReportTypeEnumyang dapat dilewati antar metode di semua kelas saya, tetapi kemudian saya harus meneruskannya di URL jadi saya menggunakan metode ordinal untuk mendapatkan nilai int. Setelah saya mendapatkannya di halaman JSP saya yang lain, saya perlu mengonversinya untuk kembali ke ReportTypeEnumsehingga saya bisa meneruskannya.

Bagaimana saya bisa mengubah ordinal ke ReportTypeEnum?

Menggunakan Java 6 SE.

Untuk mengubah ordinal menjadi represantation enumnya, Anda mungkin ingin melakukan ini:

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

Harap perhatikan batasan array.

Perhatikan bahwa setiap panggilan untuk values()mengembalikan array yang baru dikloning yang mungkin berdampak pada kinerja secara negatif. Anda mungkin ingin men-cache array jika itu akan sering dipanggil.

Contoh kode tentang cara cachevalues() .

_{Jawaban ini diedit untuk memasukkan umpan balik yang diberikan di dalam komentar}

Ini hampir pasti merupakan ide yang buruk . Tentu saja jika ordinal secara de-facto tetap ada (misalnya karena seseorang telah menandai URL) - itu berarti Anda harus selalu menjaga enumpemesanan di masa depan, yang mungkin tidak jelas bagi pengelola kode di telepon.

Mengapa tidak mengkodekan enummenggunakan myEnumValue.name()(dan mendekode via ReportTypeEnum.valueOf(s)) sebagai gantinya?

Jika saya akan menggunakan values()banyak:

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

Sementara itu dimanapun.java:

Suit suit = Suit.values[ordinal];

Pikirkan batasan array Anda.

Saya setuju dengan kebanyakan orang bahwa menggunakan ordinal mungkin adalah ide yang buruk. Saya biasanya memecahkan masalah ini dengan memberikan enum konstruktor pribadi yang dapat mengambil misalnya nilai DB kemudian membuat fromDbValuefungsi statis mirip dengan yang ada di jawaban 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;
    }

}

Sekarang Anda dapat mengubah urutan tanpa mengubah pencarian dan sebaliknya.

Anda bisa menggunakan tabel pencarian statis:

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

Inilah yang saya gunakan. Saya tidak berpura-pura bahwa ini jauh kurang "efisien" daripada solusi sederhana di atas. Apa yang dilakukannya adalah memberikan pesan pengecualian yang jauh lebih jelas daripada "ArrayIndexOutOfBounds" ketika nilai ordinal yang tidak valid digunakan dalam solusi di atas.

Itu memanfaatkan fakta bahwa javadoc EnumSet menentukan elemen pengembalian iterator dalam urutan alami mereka. Ada yang menegaskan kalau itu tidak benar.

Tes JUnit4 menunjukkan bagaimana ini digunakan.

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

Inilah yang saya lakukan di Android dengan 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];
    }
}

ini singkat dan saya tidak perlu khawatir tentang memiliki pengecualian di Proguard

Anda dapat mendefinisikan metode sederhana seperti:

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

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

Dan gunakan seperti:

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

kelas tes

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

Saya menghargai bahwa Anda berbagi dengan kami jika Anda memiliki kode yang lebih efisien, Enum saya besar dan terus-menerus dipanggil ribuan kali.

Jadi salah satu caranya adalah melakukan ExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];yang berfungsi dan mudah, namun, seperti yang disebutkan sebelumnya, ExampleEnum.values()mengembalikan array yang dikloning untuk setiap panggilan. Itu bisa sangat mahal. Kita bisa menyelesaikannya dengan cara cache array seperti itu ExampleEnum[] values = values(). Ini juga "berbahaya" untuk memungkinkan array cache kita untuk dimodifikasi. Seseorang dapat menulis ExampleEnum.values[0] = ExampleEnum.type2;Jadi saya akan menjadikannya pribadi dengan metode accessor yang tidak melakukan penyalinan tambahan.

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

Anda akan menggunakan ExampleEnum.value(ordinal)untuk mendapatkan nilai enum yang terkaitordinal

Setiap enum memiliki nama (), yang memberikan string dengan nama anggota enum.

Diberikan enum Suit{Heart, Spade, Club, Diamond}, Suit.Heart.name()akan memberi Heart.

Setiap enum memiliki valueOf()metode, yang mengambil tipe enum dan string, untuk melakukan operasi terbalik:

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

Mengapa ada orang yang menggunakan tata cara di luar saya. Mungkin nanodetik lebih cepat, tetapi tidak aman, jika anggota enum berubah, karena pengembang lain mungkin tidak menyadari beberapa kode bergantung pada nilai-nilai ordinal (terutama di halaman JSP yang dikutip dalam pertanyaan, overhead jaringan dan basis data sepenuhnya mendominasi waktu, tidak menggunakan bilangan bulat di atas string).