在给定以下枚举的情况下，将 Int 转换为 Java 中的枚举的正确方法是什么？
public enum MyEnum
{
EnumValue1,
EnumValue2
}
MyEnum enumValue = (MyEnum) x; //Doesn't work???
【问题讨论】：
标签： java casting enums ordinal
这不是通常会做的事情，所以我会重新考虑。但话虽如此，基本操作是：int --> enum 使用EnumType.values()[intNum]，以及 enum --> int 使用enumInst.ordinal()。
但是，由于values() 的任何实现都别无选择，只能为您提供数组的副本（java 数组从不只读），因此最好使用EnumMap 来缓存枚举—— > int 映射。
【讨论】：
编写了这个实现。它允许缺失值、负值并保持代码一致。地图也被缓存。使用接口并需要 Java 8。
枚举
public enum Command implements OrdinalEnum{
PRINT_FOO(-7),
PRINT_BAR(6),
PRINT_BAZ(4);
private int val;
private Command(int val){
this.val = val;
}
public int getVal(){
return val;
}
private static Map<Integer, Command> map = OrdinalEnum.getValues(Command.class);
public static Command from(int i){
return map.get(i);
}
}
界面
public interface OrdinalEnum{
public int getVal();
@SuppressWarnings("unchecked")
static <E extends Enum<E>> Map<Integer, E> getValues(Class<E> clzz){
Map<Integer, E> m = new HashMap<>();
for(Enum<E> e : EnumSet.allOf(clzz))
m.put(((OrdinalEnum)e).getVal(), (E)e);
return m;
}
}
【讨论】：
在 Kotlin 中：
enum class Status(val id: Int) {
NEW(0), VISIT(1), IN_WORK(2), FINISHED(3), CANCELLED(4), DUMMY(5);
companion object {
private val statuses = Status.values().associateBy(Status::id)
fun getStatus(id: Int): Status? = statuses[id]
}
}
用法：
val status = Status.getStatus(1)!!
【讨论】：
根据@ChadBefus 的回答和@shmosel 评论，我建议使用它。 （高效查找，适用于纯 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());
}
}
【讨论】：
你可以这样试试。
创建具有元素 id 的类。
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 static MyEnum fromId(int id) {
for (MyEnum type : values()) {
if (type.getId() == id) {
return type;
}
}
return null;
}
}
现在使用 id 作为 int 获取此枚举。
MyEnum myEnum = MyEnum.fromId(5);
【讨论】：
如果对他人有帮助，我更喜欢的选项（此处未列出）使用Guava's Maps functionality：
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);
}
}
默认情况下，您可以使用null，您可以使用throw IllegalArgumentException 或您的fromInt 可以返回Optional，无论您喜欢什么行为。
【讨论】：
Map<Integer, MyEnum> reverseLookup = Arrays.stream(MyEnum.values()).collect(Collectors.toMap(MyEnum::getValue, Function.identity()));
getValue() 方法。
您可以遍历枚举的values() 并将枚举的整数值与给定的id 进行比较，如下所示：
public enum TestEnum {
None(0),
Value1(1),
Value2(2),
Value3(3),
Value4(4),
Value5(5);
private final int value;
private TestEnum(int value) {
this.value = value;
}
public int getValue() {
return value;
}
public static TestEnum getEnum(int value){
for (TestEnum e:TestEnum.values()) {
if(e.getValue() == value)
return e;
}
return TestEnum.None;//For values out of enum scope
}
}
并像这样使用：TestEnum x = TestEnum.getEnum(4);//Will return TestEnum.Value4
我希望这会有所帮助；）
【讨论】：
尝试MyEnum.values()[x]，其中x 必须是0 或1，即该枚举的有效序数。
请注意，在 Java 中，枚举实际上是类（因此枚举值是对象），因此您不能将 int 甚至 Integer 强制转换为枚举。
【讨论】：
MyEnum.values()，因为它很昂贵。也就是说，如果你调用它数百次。
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;
}
}
}
【讨论】：
这是我计划采用的解决方案。这不仅适用于非序列整数，还适用于您可能希望用作枚举值的基础 id 的任何其他数据类型。
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;
}
}
我只需要在特定时间（从文件加载数据时）将 id 转换为枚举，因此我没有理由始终将 Map 保留在内存中。如果您确实需要始终可以访问地图，则可以始终将其缓存为 Enum 类的静态成员。
【讨论】：
clearCachedValues （将私有字段设置回 null）。我认为MyEnum.fromInt(i) 比传递地图对象更容易理解。
这与医生的答案相同，但它显示了如何消除可变数组的问题。如果您因为分支预测而使用这种方法，那么 if 将几乎没有影响到零，并且整个代码只调用一次可变数组 values() 函数。由于这两个变量都是静态的，因此每次使用该枚举时它们也不会消耗 n * 内存。
private static boolean arrayCreated = false;
private static RFMsgType[] ArrayOfValues;
public static RFMsgType GetMsgTypeFromValue(int MessageID) {
if (arrayCreated == false) {
ArrayOfValues = RFMsgType.values();
}
for (int i = 0; i < ArrayOfValues.length; i++) {
if (ArrayOfValues[i].MessageIDValue == MessageID) {
return ArrayOfValues[i];
}
}
return RFMsgType.UNKNOWN;
}
【讨论】：
如果要给出整数值，可以使用如下结构
public enum A
{
B(0),
C(10),
None(11);
int id;
private A(int i){id = i;}
public int GetID(){return id;}
public boolean IsEmpty(){return this.equals(A.None);}
public boolean Compare(int i){return id == i;}
public static A GetValue(int _id)
{
A[] As = A.values();
for(int i = 0; i < As.length; i++)
{
if(As[i].Compare(_id))
return As[i];
}
return A.None;
}
}
【讨论】：
我缓存这些值并创建一个简单的静态访问方法：
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];
}
}
【讨论】：
values 与方法values() 同名，则不会那么混乱。我使用cachedValues 作为字段名称。
一个好的选择是避免从int 到enum 的转换：例如，如果您需要最大值，您可以比较 x.ordinal() 和 y.ordinal()并相应地返回 x 或 y。 （您可能需要重新排序您的值以使此类比较有意义。）
如果不可能，我会将MyEnum.values() 存储到静态数组中。
【讨论】：
MyEnum.values()[x] 是一项昂贵的操作。如果性能是一个问题，您可能需要执行以下操作：
public enum MyEnum {
EnumValue1,
EnumValue2;
public static MyEnum fromInteger(int x) {
switch(x) {
case 0:
return EnumValue1;
case 1:
return EnumValue2;
}
return null;
}
}
【讨论】：
MyEnum.values()[x] 是一项昂贵的操作吗？我不知道它是如何详细工作的，但对我来说，访问 Array 中的元素似乎没什么大不了的，也就是恒定时间。如果必须构建数组，则需要 O(n) 时间，这与您的解决方案的运行时间相同。
values() 每次都会生成一个新数组，因为数组是可变的，所以多次返回同一个数组是不安全的。 switch语句不一定是O(n)，可以编译成跳转表。所以洛伦佐的说法似乎是有道理的。
myEnum = myEnumValues[i] 仍将返回枚举中的第 i 项而不进行更改。
使用MyEnum enumValue = MyEnum.values()[x];
【讨论】：
Java 枚举没有与 C++ 中相同的枚举到整数映射。
也就是说，所有枚举都有一个values 方法，它返回一个可能的枚举值数组，所以
MyEnum enumValue = MyEnum.values()[x];
应该可以。这有点讨厌，如果可能的话，最好不要尝试从ints 转换为Enums（反之亦然）。
【讨论】：