Cast Int zu enum in Java

Question

Was ist der richtige Weg, um in Java ein Int in ein enum umzuwandeln, wenn das folgende enum vorliegt?

public enum MyEnum
{
    EnumValue1,
    EnumValue2
}

MyEnum enumValue = (MyEnum) x; //Doesn't work???

Answer 1

Java-Enums haben nicht die gleiche Art von Enum-zu-Int-Zuordnung wie in C++.

Das heißt, alle Enums haben eine values Methode, die ein Array mit möglichen Enum-Werten zurückgibt, also

MyEnum enumValue = MyEnum.values()[x];

sollte funktionieren. Es ist ein wenig unangenehm und es ist vielleicht besser, nicht zu versuchen, von int s zu Enum s (oder umgekehrt), wenn möglich.

Answer 2

Das wird normalerweise nicht gemacht, also würde ich das noch einmal überdenken. Aber die grundlegenden Operationen sind: int --> enum mit EnumType.values()[intNum] und enum --> int mit enumInst.ordinal() .

Da jedoch jede Implementierung von values() keine andere Wahl hat, als Ihnen eine Kopie des Arrays zu geben (Java-Arrays sind niemals schreibgeschützt), wären Sie besser bedient, wenn Sie eine EnumMap um die Zuordnung enum --> int zwischenzuspeichern.

Answer 3

Verwenden Sie MyEnum enumValue = MyEnum.values()[x];

Answer 4

Basierend auf der Antwort von @ChadBefus und dem Kommentar von @shmosel würde ich empfehlen, dies zu verwenden. (Effiziente Suche, und funktioniert auf purem Java >= 8)

import java.util.stream.Collectors;
import java.util.function.Function;
import java.util.Map;
import java.util.Arrays;

public enum MyEnum {
    OPTION_1(-66),
    OPTION_2(32);

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

    public int getValue() {
        return this.value;
    }

    private static Map<Integer, MyEnum> reverseLookup =
        Arrays.stream(MyEnum.values()).collect(Collectors.toMap(MyEnum::getValue, Function.identity()));

    public static MyEnum fromInt(final int id) {
        return reverseLookup.getOrDefault(id, OPTION_1);
    }
    public static void main(String[] args) {
        System.out.println(fromInt(-66).toString());
    }
}

Answer 5

Hier ist die Lösung, die ich vorhabe. Dies funktioniert nicht nur mit nicht-sequentiellen Ganzzahlen, aber es sollte mit jedem anderen Datentyp arbeiten, die Sie als die zugrunde liegende id für Ihre Enum-Werte verwenden möchten.

public Enum MyEnum {
    THIS(5),
    THAT(16),
    THE_OTHER(35);

    private int id; // Could be other data type besides int
    private MyEnum(int id) {
        this.id = id;
    }

    public int getId() {
        return this.id;
    }

    public static Map<Integer, MyEnum> buildMap() {
        Map<Integer, MyEnum> map = new HashMap<Integer, MyEnum>();
        MyEnum[] values = MyEnum.values();
        for (MyEnum value : values) {
            map.put(value.getId(), value);
        }

        return map;
    }
}

Ich muss nur id's in Enums zu bestimmten Zeiten konvertieren (beim Laden von Daten aus einer Datei), so gibt es keinen Grund für mich, die Map im Speicher zu allen Zeiten zu halten. Wenn Sie die Map benötigen, um jederzeit zugänglich zu sein, können Sie sie immer als statisches Mitglied Ihrer Enum-Klasse zwischenspeichern.