java enum int 转换为枚举_关于java:从枚举序号转换为枚举类型

我有一个枚举类型ReportTypeEnum,它在所有类的方法之间传递,但是我需要在URL上传递它,所以我使用序数方法来获取int值。在我把它放到我的另一个JSP页面之后,我需要将它转换回一个ReportTypeEnum,以便继续传递它。

如何将序数转换为ReportTypeEnum?

使用Java 6 SE。

没有Java 6 ee,直到现在(AFAIK)。Java se 6,Java ee 5.

我的爪哇

要将序数转换为其枚举重新表示,您可能需要执行以下操作:

ReportTypeEnum value = ReportTypeEnum.values()[ordinal];

请注意数组边界。

请注意,对values()的每次调用都会返回一个新克隆的数组,这可能会以负面的方式影响性能。如果经常调用数组,您可能需要缓存它。

关于如何缓存values()的代码示例。

编辑此答案以包括评论中给出的反馈

例如stackoverflow.com/a/19277247

我实现了这个解决方案,但它对我不起作用。它返回的顺序值不保证与枚举类型的添加顺序匹配。我不知道这正是这个答案所提倡的,但我还是想警告人们

@icesdante:序数肯定与源中枚举值的顺序相对应。如果你观察到一种不同的行为,那么肯定是有别的问题。然而,由于其他答案中列出的所有原因,我的上述答案都不理想。

这几乎肯定是个坏主意。当然,如果序数事实上是持久的(例如,因为有人在URL上加了书签),这意味着您以后必须始终保留enum的顺序,这对于代码维护人员来说可能并不明显。

为什么不使用myEnumValue.name()编码enum(并通过ReportTypeEnum.valueOf(s)解码)?

更好的主意

我同意,这是更好的解决方案。

如果更改枚举的名称(但保留排序),会怎么样?

@阿恩-我认为这比一些没有经验的人来在开头或正确的字母/逻辑位置添加value的可能性要小得多。(逻辑的意思是,例如,TimeUnit值具有逻辑位置)

我当然更喜欢强制枚举顺序而不是枚举的名称……这就是为什么我更喜欢在数据库中存储序号而不是枚举的名称。此外,最好使用int操作而不是字符串…

我同意。在公共API中,更改枚举的名称会破坏向后兼容性,但更改顺序不会。因此,使用名称作为"密钥"更为合理。

对于值比应用程序寿命长的情况,这是一个很好的警告。通过将枚举的序号写入文件或数据库,可以(可能是在不知情的情况下)假定枚举值的顺序永远不会更改。但在很多情况下,枚举值只在程序执行期间使用。所以明智地选择,考虑约阿希姆·绍尔的回答。它实际上回答了手头的问题。;)

存储序数可以更容易地将您的想法翻译成其他语言。如果您需要用C编写一些组件呢?

让我们不要从一个简短的问题中猜测OP的持久性需求。也许这个值在有线格式中的停留时间不会超过一个用户会话。或者可能是。

我强烈反对。枚举类型是为了顺序而引入的,例如在pascal中,这样每个枚举值都可以相互比较。

在Android上,如果您存储枚举名并使用proguard,那么您需要确保proguard不会混淆枚举名。

如果我要经常使用values():

enum Suit {

Hearts, Diamonds, Spades, Clubs;

public static final Suit values[] = values();

}

同时where.java:

Suit suit = Suit.values[ordinal];

注意阵列边界。

+1这是迄今为止最好的解决方案imho,因为可以传递顺序,特别是在android.os.message中。

这是非常令人担忧的,因为数组是可变的。尽管值[]是最终值,但它不会阻止代码中的某个地方出现Suit.values[0] = Suit.Diamonds;。理想情况下,这永远不会发生,但不暴露可变字段的总体原则仍然适用。对于这种方法,考虑使用Collections.unmodifiableList或类似的方法。

-private static final suit values[]=values();public static suit[]getvalues()返回值;

@pratyush使数组变量不可变,但不改变其内容。我仍然可以做getValues()[0]=somethinglese;

我同意大多数人的看法,使用序数可能是一个坏主意。我通常通过给枚举一个私有的构造函数来解决这个问题,该构造函数可以例如一个db值,然后创建一个与jan答案中的函数类似的静态fromDbValue函数。

public ReportTypeEnum {

R1(1),

R2(2),

R3(3),

R4(4),

R5(5),

R6(6),

R7(7),

R8(8);

private static Logger log = LoggerFactory.getLogger(ReportEnumType.class);

private static Map lookup;

private Integer dbValue;

private ReportTypeEnum(Integer dbValue) {

this.dbValue = dbValue;

}

static {

try {

ReportTypeEnum[] vals = ReportTypeEnum.values();

lookup = new HashMap(vals.length);

for (ReportTypeEnum  rpt: vals)

lookup.put(rpt.getDbValue(), rpt);

}

catch (Exception e) {

// Careful, if any exception is thrown out of a static block, the class

// won't be initialized

log.error("Unexpected exception initializing" + ReportTypeEnum.class, e);

}

}

public static ReportTypeEnum fromDbValue(Integer dbValue) {

return lookup.get(dbValue);

}

public Integer getDbValue() {

return this.dbValue;

}

}

现在,您可以在不更改查找的情况下更改顺序,反之亦然。

这是正确的答案。与其他更直接但可能无效的答案相比(由于未来代码的变化),它得到的分数如此之少,我很惊讶。

您可以使用静态查阅表格:

public enum Suit {

spades, hearts, diamonds, clubs;

private static final Map lookup = new HashMap();

static{

int ordinal = 0;

for (Suit suit : EnumSet.allOf(Suit.class)) {

lookup.put(ordinal, suit);

ordinal+= 1;

}

}

public Suit fromOrdinal(int ordinal) {

return lookup.get(ordinal);

}

}

也见枚举。

真的!哇!当然,这很干净,但是…你知道-我内心的C程序员痛苦地尖叫着,因为你分配了一个完整的哈希图,并在里面执行查找,所有这些都只是为了基本上管理4个常量:黑桃、红心、钻石和梅花!C程序员将为每个字符分配1个字节:"const char clubs=0;"等…是的,hashmap查找是o(1),但是hashmap的内存和CPU开销,在这种情况下,使它比直接调用.values()慢很多个数量级,而且资源消耗也很大!难怪如果人们这样写的话,Java就是一个记忆之王…

不是每个节目都需要一场三人A的比赛。在许多情况下,将内存和CPU用于类型安全、可读性、可维护性、跨平台支持、垃圾收集等方面。是合理的。更高层次的语言存在是有原因的。

但是,如果您的密钥范围始终是0...(n-1),那么数组的代码更少,可读性也更高;性能提升只是一个额外的好处。private static final Suit[] VALUES = values();和public Suit fromOrdinal(int ordinal) { return VALUES[ordinal]; }。额外的优点:在无效的序号上立即崩溃,而不是静默返回空值。(并非总是优势。但通常情况下)

这是我用的。我并没有假装它远不如上述简单的解决方案"高效"。它所做的是提供比"arrayindexoutofbounds"更清晰的异常消息,因为在上面的解决方案中使用了无效的序号。

它利用了这样一个事实:Enumset JavaDoc以自然顺序指定迭代器返回元素。如果这不正确,就有断言。

JUnit4测试演示了如何使用它。

/**

* convert ordinal to Enum

* @param clzz may not be null

* @param ordinal

* @return e with e.ordinal( ) == ordinal

* @throws IllegalArgumentException if ordinal out of range

*/

public static > E lookupEnum(Class clzz, int ordinal) {

EnumSet set = EnumSet.allOf(clzz);

if (ordinal < set.size()) {

Iterator iter = set.iterator();

for (int i = 0; i < ordinal; i++) {

iter.next();

}

E rval = iter.next();

assert(rval.ordinal() == ordinal);

return rval;

}

throw new IllegalArgumentException("Invalid value" + ordinal +" for" + clzz.getName( ) +", must be

}

@Test

public void lookupTest( ) {

java.util.concurrent.TimeUnit tu = lookupEnum(TimeUnit.class, 3);

System.out.println(tu);

}

这就是我用Proguard在Android上所做的:

public enum SomeStatus {

UNINITIALIZED, STATUS_1, RESERVED_1, STATUS_2, RESERVED_2, STATUS_3;//do not change order

private static SomeStatus[] values = null;

public static SomeStatus fromInteger(int i) {

if(SomeStatus.values == null) {

SomeStatus.values = SomeStatus.values();

}

if (i < 0) return SomeStatus.values[0];

if (i >= SomeStatus.values.length) return SomeStatus.values[0];

return SomeStatus.values[i];

}

}

它很短,我不需要担心Proguard中出现异常

您可以定义一个简单的方法,例如:

public enum Alphabet{

A,B,C,D;

public static Alphabet get(int index){

return Alphabet.values()[index];

}

}

使用方法如下:

System.out.println(Alphabet.get(2));

所以有一种方法是doExampleEnum valueOfOrdinal = ExampleEnum.values()[ordinal];,它工作起来很容易,但是,如前所述,ExampleEnum.values()为每个调用返回一个新的克隆数组。那可能是不必要的昂贵。我们可以通过缓存类似于ExampleEnum[] values = values()的数组来解决这个问题。允许修改缓存数组也是"危险的"。有人可以编写ExampleEnum.values[0] = ExampleEnum.type2;,这样我就可以使用不做额外复制的访问器方法将其私有化。

private enum ExampleEnum{

type0, type1, type2, type3;

private static final ExampleEnum[] values = values();

public static ExampleEnum value(int ord) {

return values[ord];

}

}

您可以使用ExampleEnum.value(ordinal)来获取与ordinal关联的枚举值。

public enum Suit implements java.io.Serializable, Comparable{

spades, hearts, diamonds, clubs;

private static final Suit [] lookup  = Suit.values();

public Suit fromOrdinal(int ordinal) {

if(ordinal< 1 || ordinal> 3) return null;

return lookup[value-1];

}

}

测试类

public class MainTest {

public static void main(String[] args) {

Suit d3 = Suit.diamonds;

Suit d3Test = Suit.fromOrdinal(2);

if(d3.equals(d3Test)){

System.out.println("Susses");

}else System.out.println("Fails");

}

}

我很感谢您与我们分享,如果您有一个更有效的代码,我的枚举是巨大的,经常被调用数千次。

每个枚举都有name(),它给出一个具有枚举成员名称的字符串。

鉴于enum Suit{Heart, Spade, Club, Diamond},Suit.Heart.name()将给予Heart。

每个枚举都有一个valueOf()方法,它采用枚举类型和字符串来执行反向操作:

Enum.valueOf(Suit.class,"Heart")返回Suit.Heart。

为什么有人会使用序数,我无法理解。它可能快纳秒,但如果枚举成员发生变化,这是不安全的,因为另一个开发人员可能不知道某些代码依赖于序数值(特别是在问题中引用的JSP页面中,网络和数据库开销完全支配了时间,而不是在字符串上使用整数)。

因为比较整数比比较字符串快得多?

但如果有人修改枚举(添加/重新排序memvers),则序号将更改。有时,它是关于安全而不是速度的,特别是在JSP页面上,网络延迟是比较整数数组(字符串)和单个整数之间差异的1000000倍。

ToString可以被重写,因此它可能不会返回枚举名称。方法名()给出了枚举名(它是最终的)

代码注释和应用程序版本也是一回事(这样一来,文件格式可能更简单、更小)

表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
相关推荐
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页