Dostęp do metod .values ​​() i .ordinal() arbitralnego wyliczenia?

Question

Chciałbym mieć klasę, która emuluje EnumMap, ale przechowuje wartości int zamiast jakiegoś obiektu. Teraz możesz oczywiście stworzyć mapę EnumMap, która mapuje do liczb całkowitych, ale to dużo autoboxingu, którego chciałbym uniknąć, jeśli to możliwe.

Więc chciałbym klasę tak:

public class EnumIntAttributeMap 
{ 
    enum Attribute 
    { 
     Height, Weight; 
    } 

    private final int[] values; 

    public EnumIntAttributeMap() 
    { 
     this.values = new int[Attribute.values().length]; 
    } 

    public int getValue(Attribute a) 
    { 
     return this.values[a.ordinal()]; 
    } 

    public void setValue(Attribute a, int value) 
    { 
     this.values[a.ordinal()] = value; 
    } 
} 

wyjątkiem Chciałbym zrobić wersję, która jest nazwą rodzajową we wszystkich teksty stałe. Teraz, ponieważ metody .values ​​() i .ordinal() są domyślnie dodawane przez kompilator, wydaje się, że jedynym sposobem uzyskania do nich dostępu byłaby refleksja, która pochłonęłaby wzrost wydajności, który próbuję osiągnąć, unikając auto-boxing, ale może jest coś, czego mi brakuje.

Jakieś myśli?

EDIT:

Myślę, że moje początkowe pytanie było jasne. Chciałbym klasy, która bierze (jako parametr ogólny) wyliczenie, a następnie może korzystać z tych samych operacji.

Mogę więc używać go z dowolnym wyliczeniem, bez potrzeby pisania zajęć dla każdego rodzaju wyliczenia za każdym razem. Takich jak:

enum Attribute { Height, Weight } 

enum AbilityScore {Str, Dex, Con, Int, Wis, Cha} 

IdealClass<Attribute> attributeVersion; 

IdealClass<AbilityScore> abilityScoreVersion; 

i tak dalej.

Answer 1

to rozwiązanie:

public class EnumIntMap<E extends Enum<E>> { 

    private final int[] values; 

    public EnumIntMap(Class<E> cls) 
    { 
     this.values = new int[cls.getEnumConstants().length]; 
    } 

    public int getValue(E a) 
    { 
     return this.values[a.ordinal()]; 
    } 

    public void setValue(E a, int value) 
    { 
     this.values[a.ordinal()] = value; 
    } 
} 

Będziesz musiał zainicjować mapę także z klasą wyliczenia.

enum Attribute { Height, Weight } 

enum AbilityScore {Str, Dex, Con, Int, Wis, Cha} 

EnumIntMap<Attribute> attributeVersion = new EnumIntMap(Attribute.class); 

EnumIntMap<AbilityScore> abilityScoreVersion = new EnumIntMap(AbilityScore.class); 

Answer 2

Przeczytaj to: Oracle's Doc on Enums.

Myślę, że można zrobić coś, co jest podobny do przykładu planety:

public enum YourEnum{ 
    HEIGHT (0), 
    WIDTH (1); 

    private final int index; 

    YourEnum(int index) { 
     this.index = index; 
    } 
    public int index() { return index; } 
} 

Answer 3

To co ja osobiście używać i daje mi piękny normalizacji w API

Common Interface:

public interface IValueEnum<T> {  
    T value(); 
} 

Enum implementuje go w następujący sposób:

public enum MyEnum implements IValueEnum<Integer> { 
    WIDTH(1), 
    HEIGHT(2); 

    private final int value; 
    MyEnum(int value) { this.value = value; } 

    @Override 
    public Integer value() { 
     return value; 
    } 
} 

Teraz możesz uzyskać ostateczną wartość, przechodząc przez MyEnum.WIDTH.value(), itp. Ponieważ używa generycznych innych wyrażeń, może użyć Longs lub String lub co masz. Pozwala na posiadanie jednego prostego interfejsu opartego na Enum w aplikacji. Pozwala również być całkowicie generycznych w mapy, itp

EDIT: Na podstawie Nowego przykładu

public class IdealClass<T extends Enum> { 

    T enumValue; 

    public IdealClass() { 
    } 

} 

Answer 4

Wszystko java Enum dorozumiany przedłużyć java.lang.Enum, więc myślę, że to, czego szukasz jest:

public class EnumIntAttributeMap<E extends java.lang.Enum<E>> { 
    // [...] 
} 

Answer 5

Kluczem do tego genetycznie wiedząc rodzajową związaną z wyliczenia:

<T extends Enum<T>> 

Twoja klasa może pracować dla żadnego enum następująco:

public class EnumIntAttributeMap<T extends Enum<T>> { 
    private final int[] values; 
    private final Class<T> clazz; 

    public EnumIntAttributeMap(Class<T> clazz) { 
     this.clazz = clazz; 
     this.values = new int[clazz.getEnumConstants().length]; 
    } 

    public int getValue(T a) { 
     return this.values[a.ordinal()]; 
    } 

    public void setValue(T a, int value) { 
     this.values[a.ordinal()] = value; 
    } 
} 

Należy pamiętać, że Konstruktor wymaga tokena typu , który jest wymagany z powodu wymazywania typu środowiska wykonawczego Java.