Cast Int para enum en Java



6 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???



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.




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




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.




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



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.




Related