blocks|key|694152|text|尝试MyEnum.values()[x]，其中x必须是0或1，即该枚举的有效序号。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|694153|请注意，在Java中，枚举实际上是类(因此枚举值是对象)，因此不能将int甚至Integer强制转换为枚举。|694154|entityMap^0|2|I|N|1|R|1|T|1|0|Y|3|13|7|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

Try <code>MyEnum.values()[x]</code> where <code>x</code> must be <code>0</code> or <code>1</code>, i.e. a valid ordinal for that enum. 

Note that in Java enums actually are classes (and enum values thus are objects) and thus you can't cast an <code>int</code> or even <code>Integer</code> to an enum.

blocks|key|694282|text|MyEnum.values()[x]是一个昂贵的操作。如果性能令人担忧，您可能需要执行以下操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|694283|public+enum+MyEnum+{
++++EnumValue1,
++++EnumValue2;

++++public+static+MyEnum+fromInteger(int+x)+{
++++++++switch(x)+{
++++++++case+0:
++++++++++++return+EnumValue1;
++++++++case+1:
++++++++++++return+EnumValue2;
++++++++}
++++++++return+null;
++++}
}|code-block|syntax|javascript|694284|entityMap^0|0|I|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<code>MyEnum.values()[x]</code> is an expensive operation. If the performance is a concern, you may want to do something like this:

<pre><code>public enum MyEnum {
 EnumValue1,
 EnumValue2;

 public static MyEnum fromInteger(int x) {
 switch(x) {
 case 0:
 return EnumValue1;
 case 1:
 return EnumValue2;
 }
 return null;
 }
}
</code></pre>

blocks|key|694357|text|如果你想给出整数值，你可以使用如下结构|type|unstyled|depth|inlineStyleRanges|entityRanges|data|694358|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%2B%2B)
++++++++++++{
++++++++++++++++if(As[i].Compare(_id))
++++++++++++++++++++return+As[i];
++++++++++++}
++++++++++++return+A.None;
++++++++}
}|code-block|syntax|javascript|694359|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to give your integer values, you can use a structure like below

<pre><code>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 &lt; As.length; i++)
 {
 if(As[i].Compare(_id))
 return As[i];
 }
 return A.None;
 }
}
</code></pre>

blocks|key|694465|text|你可以试着这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|694466|使用元素id创建类。|694467|++++++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;
++++++++++++}
++++++}|code-block|syntax|javascript|694468|现在使用id作为int来获取此Enum。|694469|MyEnum+myEnum+=+MyEnum.fromId(5);|694470|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can try like this. 
Create Class with element id. 

<pre><code> 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;
 }
 }
</code></pre>

Now Fetch this Enum using id as int. 

<pre><code>MyEnum myEnum = MyEnum.fromId(5);
</code></pre>

blocks|key|910363|text|我缓存这些值并创建一个简单的静态访问方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|910364|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];
++++}
}|code-block|syntax|javascript|910365|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I cache the values and create a simple static access method:

<pre><code>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];
 }
}
</code></pre>

blocks|key|910250|text|Java枚举不具有与C%2B%2B中相同的枚举到整型映射。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|910251|也就是说，所有枚举都有一个values方法，该方法返回可能枚举值的数组，因此|offset|length|style|CODE|910252|MyEnum+enumValue+=+MyEnum.values()[x];|code-block|syntax|javascript|910253|应该行得通。这有点麻烦，如果可能的话，最好不要尝试从ints转换到Enums+(反之亦然)。|910254|entityMap^0|0|D|6|0|0|Q|3|X|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

Java enums don't have the same kind of enum-to-int mapping that they do in C++.

That said, all enums have a <code>values</code> method that returns an array of possible enum values, so

<pre><code>MyEnum enumValue = MyEnum.values()[x];
</code></pre>

should work. It's a little nasty and it might be better to not try and convert from <code>int</code>s to <code>Enum</code>s (or vice versa) if possible.

blocks|key|910299|text|这不是通常会做的事情，所以我会重新考虑。但话虽如此，基本操作是:使用EnumType.values()[intNum]的int+-->枚举和使用enumInst.ordinal()的enum+-->+int。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|910300|但是，由于任何values()实现都别无选择，只能为您提供一个数组副本(java数组永远不是只读的)，最好使用EnumMap缓存枚举-->+int映射。|910301|entityMap^0|Y|P|20|I|0|7|8|1J|7|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

This not something that is usually done, so I would reconsider. But having said that, the fundamental operations are: int --&gt; enum using <code>EnumType.values()[intNum]</code>, and enum --&gt; int using <code>enumInst.ordinal()</code>.
However, since any implementation of <code>values()</code> has no choice but to give you a copy of the array (java arrays are never read-only), you would be better served using an <code>EnumMap</code> to cache the enum --&gt; int mapping.

blocks|key|694161|text|使用MyEnum+enumValue+=+MyEnum.values()[x];|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|694162|entityMap^0|2|12|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Use <code>MyEnum enumValue = MyEnum.values()[x];</code>

blocks|key|694438|text|这是我计划采用的解决方案。这不仅适用于非连续整数，而且还适用于您可能想要用作枚举值的底层id的任何其他数据类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|694439|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;
++++}
}|code-block|syntax|javascript|694440|我只需要在特定时间将id转换为枚举(当从文件加载数据时)，所以我没有理由一直将Map保存在内存中。如果您确实需要映射始终可访问，则始终可以将其作为Enum类的静态成员进行缓存。|694441|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's the solution I plan to go with. Not only does this work with non-sequential integers, but it should work with any other data type you may want to use as the underlying id for your enum values.

<pre><code>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&lt;Integer, MyEnum&gt; buildMap() {
 Map&lt;Integer, MyEnum&gt; map = new HashMap&lt;Integer, MyEnum&gt;();
 MyEnum[] values = MyEnum.values();
 for (MyEnum value : values) {
 map.put(value.getId(), value);
 }

 return map;
 }
}
</code></pre>

I only need to convert id's to enums at specific times (when loading data from a file), so there's no reason for me to keep the Map in memory at all times. If you do need the map to be accessible at all times, you can always cache it as a static member of your Enum class.

blocks|key|694688|text|为了防止对他人有所帮助，我更喜欢的选项使用Guava's+Maps+functionality，此处没有列出|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|694689|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);
++++}
}|code-block|syntax|javascript|694690|默认情况下，你可以使用null，你可以使用throw+IllegalArgumentException，或者你的fromInt可以返回一个Optional，任何你喜欢的行为。|style|CODE|694691|entityMap|0|LINK|mutability|MUTABLE|url|https://google.github.io/guava/releases/21.0/api/docs/com/google/common/collect/Maps.html#uniqueIndex-java.lang.Iterable-com.google.common.base.Function-^0|L|Q|0|0|0|B|4|L|U|1K|7|1X|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]|$A|12|B|13|K|L]|$A|14|B|15|K|L]|$A|16|B|17|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

In case it helps others, the option I prefer, which is not listed here, uses <a href="https://google.github.io/guava/releases/21.0/api/docs/com/google/common/collect/Maps.html#uniqueIndex-java.lang.Iterable-com.google.common.base.Function-" rel="noreferrer">Guava's Maps functionality</a>:

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

 public static MyEnum fromInt(final int id) {
 return reverseLookup.getOrDefault(id, OPTION_1);
 }
}
</code></pre>

With the default you can use <code>null</code>, you can <code>throw IllegalArgumentException</code> or your <code>fromInt</code> could return an <code>Optional</code>, whatever behavior you prefer.

blocks|key|910832|text|基于@ChadBefus的回答和@shmosel的评论，我推荐使用这个。(高效查找，适用于纯java+>=+8)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|910833|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());
++++}
}|code-block|syntax|javascript|910834|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Based on @ChadBefus 's answer and @shmosel comment, I'd recommend using this. (Efficient lookup, and works on pure java >= 8)

<pre><code>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&lt;Integer, MyEnum&gt; 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());
 }
}
</code></pre>

blocks|key|910688|text|您可以迭代枚举的values()，并将枚举的整数值与给定的id进行比较，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|910689|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
++++}
}|code-block|syntax|javascript|910690|就像这样使用：|910691|TestEnum+x+=+TestEnum.getEnum(4);//Will+return+TestEnum.Value4|910692|我希望这能有所帮助;)|910693|entityMap^0|8|8|T|2|0|0|0|0|1Q|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

You can iterate over <code>values()</code> of enum and compare integer value of enum with given <code>id</code> like below:

<pre><code>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
 }
}
</code></pre>

And use just like this: 
<code>TestEnum x = TestEnum.getEnum(4);//Will return TestEnum.Value4</code> 
I hope this helps ;)

blocks|key|910638|text|写了这个实现。它允许缺失值、负值，并保持代码的一致性。地图也会被缓存。使用接口并需要Java+8。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|910639|枚举|910640|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);
++++}
}|code-block|syntax|javascript|910641|接口|910642|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;
++++}
}|910643|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Wrote this implementation. It allows for missing values, negative values and keeps code consistent. The map is cached as well. Uses an interface and needs Java 8.

Enum

<pre><code>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&lt;Integer, Command&gt; map = OrdinalEnum.getValues(Command.class);
 public static Command from(int i){
 return map.get(i);
 }
}
</code></pre>

Interface

<pre><code>public interface OrdinalEnum{
 public int getVal();

 @SuppressWarnings("unchecked")
 static &lt;E extends Enum&lt;E&gt;&gt; Map&lt;Integer, E&gt; getValues(Class&lt;E&gt; clzz){
 Map&lt;Integer, E&gt; m = new HashMap&lt;&gt;();
 for(Enum&lt;E&gt; e : EnumSet.allOf(clzz))
 m.put(((OrdinalEnum)e).getVal(), (E)e);

 return m;
 }
}
</code></pre>

blocks|key|910436|text|这与医生的答案相同，但它展示了如何消除可变数组的问题。如果您使用这种方法，因为首先是分支预测，If的效果将非常小甚至为零，并且整个代码只调用一次可变数组的values()函数。因为这两个变量都是静态的，所以它们不会在每次使用此枚举时都消耗n*个内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|910437|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%2B%2B)+{
++++++++if+(ArrayOfValues[i].MessageIDValue+==+MessageID)+{
++++++++++++return+ArrayOfValues[i];
++++++++}
++++}
++++return+RFMsgType.UNKNOWN;
}|code-block|syntax|javascript|910438|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is the same answer as the doctors but it shows how to eliminate the problem with mutable arrays. If you use this kind of approach because of branch prediction first if will have very little to zero effect and whole code only calls mutable array values() function only once. As both variables are static they will not consume n * memory for every usage of this enumeration too.

<pre><code>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 &lt; ArrayOfValues.length; i++) {
 if (ArrayOfValues[i].MessageIDValue == MessageID) {
 return ArrayOfValues[i];
 }
 }
 return RFMsgType.UNKNOWN;
}
</code></pre>

blocks|key|694508|text|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;
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|694509|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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;
 }
 }
}
</code></pre>

blocks|key|910854|text|在Kotlin：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|910855|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]
++++}
}|code-block|syntax|javascript|910856|用法：|910857|val+status+=+Status.getStatus(1)!!|910858|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

In Kotlin:

<pre><code>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]
 }
}
</code></pre>

Usage:

<pre><code>val status = Status.getStatus(1)!!
</code></pre>

What is the correct way to cast an Int to an enum in Java given the following enum?

<pre><code>public enum MyEnum
{
 EnumValue1,
 EnumValue2
}


MyEnum enumValue = (MyEnum) x; //Doesn't work???
</code></pre>

Cast Int to enum in Java

Kotlin

Java

在给定以下枚举的情况下，在Java中将Int转换为枚举的正确方法是什么？public enum MyEnum{    EnumValue1,    EnumValue2}MyEnum enumValue = (MyEnum) x; //Doesn't work???

问将Int强制转换为Java中的枚举
EN

回答 16

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将Int强制转换为Java中的枚举EN

回答 16

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将Int强制转换为Java中的枚举
EN