Enum ordinal biriminden enum tipine dönüştürme

ReportTypeEnumTüm sınıflarımda yöntemler arasında geçen enum türü ettik ama sonra int değeri almak için ordinal yöntemi kullanmak bu yüzden URL bu geçmek gerekir. Diğer JSP sayfama aldıktan sonra, onu ReportTypeEnumgeçirmeye devam edebilmem için bire geri dönüştürmem gerekiyor.

Ordinal'i nasıl dönüştürebilirim ReportTypeEnum?

Java 6 SE kullanma.

Bir ordinali enum temsiline dönüştürmek için bunu yapmak isteyebilirsiniz:

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

Lütfen dizi sınırlarına dikkat edin.

Her arama çağrısının, values()performansı olumsuz yönde etkileyebilecek yeni klonlanmış bir dizi döndürdüğünü unutmayın . Diziyi sık sık arayacaksanız önbelleğe almak isteyebilirsiniz.

Nasıl önbelleğe alınacağına ilişkin kod örneğivalues() .

_{Bu cevap, yorumlara verilen geri bildirimi içerecek şekilde düzenlendi}

Bu neredeyse kesinlikle kötü bir fikir . Kesinlikle ordinal fiili kalıcı ise (örneğin, birisi URL'ye yer işareti enumkoyduğu için) - bu , sıradaki kod koruyucular tarafından açıkça görülmeyen, gelecekte siparişi her zaman korumanız gerektiği anlamına gelir .

Neden kodlamak değil enumkullanarak myEnumValue.name()(ve kod çözme yoluyla ReportTypeEnum.valueOf(s)) yerine?

Çok kullanacaksam values():

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

Bu arada her yerde. Java:

Suit suit = Suit.values[ordinal];

Dizi sınırlarınıza dikkat edin.

Çoğu insanla ordinal kullanmanın muhtemelen kötü bir fikir olduğunu kabul ediyorum. Ben genellikle enum örneğin bir DB değeri alabilir özel bir yapıcı vererek fromDbValueJan'ın cevabında benzer statik bir işlev oluşturarak bu sorunu çözmek .

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

}

Şimdi, sıralamayı değiştirmeden sıralamayı değiştirebilirsiniz.

Sen olabilir statik arama tablosu kullanın:

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

Ben bunu kullanıyorum. Yukarıdaki basit çözümlerden çok daha az "verimli" olduğunu iddia etmiyorum. Yaptığı şey, yukarıdaki çözümde geçersiz bir sıra değeri kullanıldığında "ArrayIndexOutOfBounds" ifadesinden çok daha net bir istisna mesajı sağlamaktır.

EnumSet javadoc'un yineleyicinin öğeleri doğal düzeninde döndürdüğü gerçeğini kullanır. Bu doğru değilse bir iddia var.

JUnit4 Testi nasıl kullanıldığını gösterir.

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

Proguard ile Android'de yaptığım şey bu:

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

kısa ve Proguard'da bir istisna hakkında endişelenmem gerekmiyor

Şunun gibi basit bir yöntem tanımlayabilirsiniz:

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

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

Ve şöyle kullanın:

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

test sınıfı

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

Daha verimli bir kodunuz varsa bizimle paylaştığınız için teşekkür ederim, Numaram büyük ve sürekli olarak binlerce kez denir.

Öyleyse bir yol ExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];hangi işe yarar ve daha önce belirtildiği gibi kolay, ExampleEnum.values()her çağrı için yeni bir klonlanmış dizi döndürür. Bu gereksiz bir şekilde pahalı olabilir. Bunu diziyi önbelleğe alarak çözebiliriz ExampleEnum[] values = values(). Ayrıca önbelleğe alınmış dizimizin değiştirilmesine izin vermek "tehlikelidir". Birisi yazabilir ExampleEnum.values[0] = ExampleEnum.type2;Bu yüzden fazladan kopyalama yapmayan bir erişimci yöntemi ile özel yapardı.

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

ExampleEnum.value(ordinal)İle ilişkili enum değerini almak için kullanırsınızordinal

Her numaralandırmada, numaralandırma üyesi adıyla bir dize veren name () vardır.

Verilen enum Suit{Heart, Spade, Club, Diamond}, Suit.Heart.name()verecek Heart.

Her numaralandırma, valueOf()ters işlemi gerçekleştirmek için bir numaralandırma türü ve bir dize alan bir yönteme sahiptir :

Enum.valueOf(Suit.class, "Heart")döner Suit.Heart.

Neden herkes ordinal kullanacak? Nanosaniye daha hızlı olabilir, ancak numaralandırma üyeleri değişirse güvenli değildir, başka bir geliştirici bazı kodların sıralı değerlere bağlı olduğunun farkında olmayabilir (özellikle soruda belirtilen JSP sayfasında, ağ ve veritabanı yükü tamamen dize üzerinde bir tamsayı kullanmayın).