Cast Int para enum en Java



Answers

MyEnum.values()[x] es una operación costosa. Si el rendimiento es una preocupación, es posible que desee hacer algo como esto:

public enum MyEnum {
    EnumValue1,
    EnumValue2;

    public static MyEnum fromInteger(int x) {
        switch(x) {
        case 0:
            return EnumValue1;
        case 1:
            return EnumValue2;
        }
        return null;
    }
}
Question

¿Cuál es la forma correcta de convertir un Int a una enumeración en Java dada la siguiente enumeración?

public enum MyEnum
{
    EnumValue1,
    EnumValue2
}


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



En caso de que ayude a otros, la opción que prefiero, que no figura aquí, usa la funcionalidad de Guava's Maps :

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 ImmutableMap<Integer, MyEnum> reverseLookup = 
            Maps.uniqueIndex(Arrays.asList(MyEnum.values())), MyEnum::getValue);

    public static MyEnum fromInt(final int id) {
        return reverseLookup.getOrDefault(id, OPTION_1);
    }
}

Con el valor predeterminado puede usar null , puede throw IllegalArgumentException o su fromInt podría devolver un Optional , sea cual sea el comportamiento que prefiera.




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




enum MyEnum {
    A(0),
    B(1);
    private final int value;
    private MyEnum(int val) {this.value = value;}
    private static final MyEnum[] values = MyEnum.values();//cache for optimization
    public static final getMyEnum(int value) { 
        try {
            return values[value];//OOB might get triggered
        } catch (ArrayOutOfBoundsException e) {
        } finally {
            return myDefaultEnumValue;
        }
    }
}



Guardo en caché los valores y creo un método de acceso estático simple:

public static enum EnumAttributeType {
    ENUM_1,
    ENUM_2;
    private static EnumAttributeType[] values = null;
    public static EnumAttributeType fromInt(int i) {
        if(EnumAttributeType.values == null) {
            EnumAttributeType.values = EnumAttributeType.values();
        }
        return EnumAttributeType.values[i];
    }
}



Una buena opción es evitar la conversión de int a enum : por ejemplo, si necesita el valor máximo, puede comparar x.ordinal () con y.ordinal () y devolver x o y correspondientemente. (Es posible que necesite volver a ordenar sus valores para que esa comparación sea significativa).

Si eso no es posible, almacenaría MyEnum.values() en una matriz estática.




Las enumeraciones de Java no tienen el mismo tipo de asignación enum-to-int que lo que hacen en C ++.

Dicho esto, todas las enumeraciones tienen un método de values que devuelve una matriz de posibles valores enum, por lo que

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

Deberia trabajar. Es un poco desagradable y podría ser mejor no intentar convertir de int s a Enum s (o viceversa) si es posible.




Links