精华内容
下载资源
问答
  • enum FruitEnum {APPLE... // 调用构造函数来构造枚举项private int value = 0;private FruitEnum(int value) { // 必须是private的,否则编译错误this.value = value;}public static FruitEnum valueOf(int value)...

    enum FruitEnum {

    APPLE(1), ORANGE(2); // 调用构造函数来构造枚举项

    private int value = 0;

    private FruitEnum(int value) { // 必须是private的,否则编译错误

    this.value = value;

    }

    public static FruitEnum valueOf(int value) { // 手写的从int到enum的转换函数

    switch (value) {

    case 1:

    return APPLE;

    case 2:

    return ORANGE;

    default:

    return null;

    }

    }

    public int value() {

    return this.value;

    }

    }

    public static void main(String[] args) {

    System.out.println(FruitEnum.APPLE.value()); // 1

    System.out.println(FruitEnum.ORANGE.value()); // 2

    System.out.println(FruitEnum.valueOf(1)); // FruitEnum.APPLE

    System.out.println(FruitEnum.valueOf(2)); // FruitEnum.ORANGE

    }

    枚举项的值从0开始递增可以使用ordinal取枚举项在整个枚举中的位置(0开始类似数组下标)

    enum MyEnum{

    FIRST_ELEMENT,

    SECOND_ELEMENT,

    }

    public static void main(String[] args) {

    System.out.println(MyEnum.FIRST_ELEMENT.ordinal()); // 0

    System.out.println(MyEnum.SECOND_ELEMENT.ordinal()); // 1

    System.out.println(MyEnum.values()[0]); // MyEnum.FIRST_ELEMENT

    System.out.println(MyEnum.values()[1]); // MyEnum.SECOND_ELEMENT

    }

    展开全文
  • 原文网址:http://iaiai.iteye.com/blog/18435531 背景在java语言中还没有引入枚举类型之前,表示枚举类型的常用模式是声明一组具有int常量。之前我们通常利用public final static 方法定义的代码如下,分别用1 表示...

    原文网址:http://iaiai.iteye.com/blog/1843553

    1   背景

    在java语言中还没有引入枚举类型之前,表示枚举类型的常用模式是声明一组具有int常量。之前我们通常利用public final static 方法定义的代码如下,分别用1 表示春天,2表示夏天,3表示秋天,4表示冬天。

    Java代码  bd35dcfcdece18a2700be40e56db1078.png

    public class Season {

    public static final int SPRING = 1;

    public static final int SUMMER = 2;

    public static final int AUTUMN = 3;

    public static final int WINTER = 4;

    }

    这种方法称作int枚举模式。可这种模式有什么问题呢,我们都用了那么久了,应该没问题的。通常我们写出来的代码都会考虑它的安全性、易用性和可读性。

    首先我们来考虑一下它的类型安全性。当然这种模式不是类型安全的。比如说我们设计一个函数,要求传入春夏秋冬的某个值。但是使用int类型,我们无法保证传入的值为合法。代码如下所示:

    Java代码  bd35dcfcdece18a2700be40e56db1078.png

    public class Season {

    public static final int SPRING = 1;

    public static final int SUMMER = 2;

    public static final int AUTUMN = 3;

    public static final int WINTER = 4;

    private String getChineseSeason(int season){

    StringBuffer result = new StringBuffer();

    switch(season){

    case Season.SPRING :

    result.append("春天");

    break;

    case Season.SUMMER :

    result.append("夏天");

    break;

    case Season.AUTUMN :

    result.append("秋天");

    break;

    case Season.WINTER :

    result.append("冬天");

    break;

    default :

    result.append("地球没有的季节");

    break;

    }

    return result.toString();

    }

    public void doSomething(){

    System.out.println(this.getChineseSeason(Season.SPRING));//这是正常的场景

    System.out.println(this.getChineseSeason(5));//这个却是不正常的场景,这就导致了类型不安全问题

    }

    public static void main(String[] arg){

    Season season = new Season();

    season.doSomething();

    }

    }

    程序getChineseSeason(Season.SPRING)是我们预期的使用方法。可getChineseSeason(5)显然就不是了,而且编译很通过,在运行时会出现什么情况,我们就不得而知了。这显然就不符合Java程序的类型安全。

    接下来我们来考虑一下这种模式的可读性。使用枚举的大多数场合,我都需要方便得到枚举类型的字符串表达式。如果将int枚举常量打印出来,我们所见到的就是一组数字,这是没什么太大的用处。我们可能会想到使用String常量代替int常量。虽然它为这些常量提供了可打印的字符串,但是它会导致性能问题,因为它依赖于字符串的比较操作,所以这种模式也是我们不期望的。

    从类型安全性和程序可读性两方面考虑,int和String枚举模式的缺点就显露出来了。幸运的是,从Java1.5发行版本开始,就提出了另一种可以替代的解决方案,可以避免int和String枚举模式的缺点,并提供了许多额外的好处。那就是枚举类型(enum type)。接下来的章节将介绍枚举类型的定义、特征、应用场景和优缺点。

    2   定义

    枚举类型(enum type)是指由一组固定的常量组成合法的类型。Java中由关键字enum来定义一个枚举类型。下面就是java枚举类型的定义。

    Java代码  bd35dcfcdece18a2700be40e56db1078.png

    public enum Season {

    SPRING, SUMMER, AUTUMN, WINTER;

    }

    3   特点

    Java定义枚举类型的语句很简约。它有以下特点:

    1)  使用关键字enum

    2)  类型名称,比如这里的Season

    3)  一串允许的值,比如上面定义的春夏秋冬四季

    4)  枚举可以单独定义在一个文件中,也可以嵌在其它Java类中

    除了这样的基本要求外,用户还有一些其他选择

    5)  枚举可以实现一个或多个接口(Interface)

    6)  可以定义新的变量

    7)  可以定义新的方法

    8)  可以定义根据具体枚举值而相异的类

    4   应用场景

    以在背景中提到的类型安全为例,用枚举类型重写那段代码。代码如下:

    Java代码  bd35dcfcdece18a2700be40e56db1078.png

    public enum Season {

    SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);

    private int code;

    private Season(int code){

    this.code = code;

    }

    public int getCode(){

    return code;

    }

    }

    Java代码  bd35dcfcdece18a2700be40e56db1078.png

    public class UseSeason {

    /**

    * 将英文的季节转换成中文季节

    * @param season

    * @return

    */

    public String getChineseSeason(Season season){

    StringBuffer result = new StringBuffer();

    switch(season){

    case SPRING :

    result.append("[中文:春天,枚举常量:" + season.name() + ",数据:" + season.getCode() + "]");

    break;

    case AUTUMN :

    result.append("[中文:秋天,枚举常量:" + season.name() + ",数据:" + season.getCode() + "]");

    break;

    case SUMMER :

    result.append("[中文:夏天,枚举常量:" + season.name() + ",数据:" + season.getCode() + "]");

    break;

    case WINTER :

    result.append("[中文:冬天,枚举常量:" + season.name() + ",数据:" + season.getCode() + "]");

    break;

    default :

    result.append("地球没有的季节 " + season.name());

    break;

    }

    return result.toString();

    }

    public void doSomething(){

    for(Season s : Season.values()){

    System.out.println(getChineseSeason(s));//这是正常的场景

    }

    //System.out.println(getChineseSeason(5));

    //此处已经是编译不通过了,这就保证了类型安全

    }

    public static void main(String[] arg){

    UseSeason useSeason = new UseSeason();

    useSeason.doSomething();

    }

    }

    引用

    [中文:春天,枚举常量:SPRING,数据:1]

    [中文:夏天,枚举常量:SUMMER,数据:2]

    [中文:秋天,枚举常量:AUTUMN,数据:3]

    [中文:冬天,枚举常量:WINTER,数据:4]

    这里有一个问题,为什么我要将域添加到枚举类型中呢?目的是想将数据与它的常量关联起来。如1代表春天,2代表夏天。

    5   总结

    那么什么时候应该使用枚举呢?每当需要一组固定的常量的时候,如一周的天数、一年四季等。或者是在我们编译前就知道其包含的所有值的集合。优点是:枚举能满足绝大部分程序员的要求的,它的简明,易用的特点是很突出的。缺点:与int常量相比,枚举有个小小的性能缺点,即装载和初始化枚举时会有空间和时间的成本。如受资源约束的设备:手机等。

    展开全文
  • Java枚举

    2021-03-08 18:54:12
    枚举其实是个特殊的 Java 类,创建枚举需用enum关键字,...,这里的 E 表示枚举类型的名称,枚举类的每个值都会映射到protected Enum(String name, int ordinal)构造函数中,每个值(如NumEnum中的ONE)的名称都被...

    枚举其实是个特殊的 Java 类,创建枚举需用enum关键字,枚举类都是java.lang.Enum的子类,java.lang.Enum是一个抽象类,枚举类型符合通用类型模式Class Enum>,这里的 E 表示枚举类型的名称,枚举类的每个值都会映射到protected Enum(String name, int ordinal)构造函数中,每个值(如NumEnum中的ONE)的名称都被转成字符串, ordinal 表示被创建的顺序(默认是0,1,2,3...)。

    枚举类enum定义如下:

    enum NumEnum{

    ONE,TWO,THREE,FOUR

    }

    实际上是调用了如下方法:

    new Enum("ONE",0);

    new Enum("TWO",1);

    new Enum("THREE",2);

    new Enum("FOUR",3);

    常用方法如下:

    //比较此枚举与指定对象的顺序

    int compareTo(E o)

    //返回与此枚举常量的枚举类型相对应的 Class 对象

    Class getDeclaringClass()

    //返回此枚举常量的名称

    String name()

    //返回枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)

    int ordinal()

    // 返回枚举常量的名称

    String toString()

    //返回带指定名称的指定枚举类型的枚举常量

    static > T valueOf(Class enumType, String name)

    NumEnum调用常用方法如下:

    System.out.println(NumEnum.ONE.compareTo(NumEnum.FOUR));// -3

    System.out.println(NumEnum.ONE.getDeclaringClass());//class com.jeeno.test.NumEnum

    System.out.println(NumEnum.TWO.name());//TWO

    System.out.println(NumEnum.THREE.ordinal());//2

    System.out.println(NumEnum.THREE.toString());//THREE

    System.out.println(NumEnum.ONE.valueOf("FOUR"));//FOUR

    实际上enum就是一个class,只不过 Java 编译器帮我们做了语法的解析和编译而已。可以把enum看成是一个普通的class,它们都可以定义一些属性和方法,不同之处是:enum不能使用extends关键字继承其他类,因为enum已经继承了java.lang.Enum(java是单一继承)。

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

    我有一个枚举类型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可以被重写,因此它可能不会返回枚举名称。方法名()给出了枚举名(它是最终的)

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

    展开全文
  • java枚举类(

    2021-03-04 02:02:07
    枚举类型:1、我们可以这样来定义一个枚举类型public enum Color{Red,Blue,Black,Green;}然后可以这样来使用:Color myColor = Color.Red2、枚举类型提供了两个有用的静态方法 values( ) 和 valueOf( ) 我们可以很...
  • 我有一个编写枚举“工作日”的任务,其中常量有多个参数.Enum类型是否有一个简短的方法来迭代它的属性(1,2,3,4,5,6,7 – 来自我的代码)或者我必须编写另一种数据类型来存储所请求的数据?那是我的代码:public enum ...
  • 原标题:Java 枚举与字符串的转换(点击上方公众号,可快速关注)来源:xieyu_zy链接:blog.csdn.net/xieyuooo/article/details/8483267文章简单,相信在很多网站都能搜索到java enum枚举的使用方式;可能有些东西我...
  • java枚举自动转换

    2021-10-09 17:35:21
    提供两个接口,分别处理以code(int类型)和name(String类型)进行转换的枚举 public interface IFeIntegerEnum { int getCode(); static <E extends Enum<?> & IFeIntegerEnum> Optional<...
  • 最近常常有一些项目需要给枚举设值一个int值,以及对int值进行反解析出枚举类型,代码如下:1 public enumMatchResultEnum {23 /**4 * 赢5 */6 WIN(0),7 /**8 * 输9 */10 LOSE(1),11 /**12 * 平局13 */14 DRAW(2);...
  • 以User类为例,User类中有个枚举类型的性别属性,如果不对其进行处理,json时会使用枚举类的toString方法,这时给前端的是个字符串而不是json对象,前端很难取出值。 未处理前: "gender":"GenderEnum.FEMALE(code...
  • 使用枚举类型代替int枚举模式(int常量)文章目录使用枚举类型代替int枚举模式(int常量)一、int枚举模式二、枚举类型三、枚举类型还允许添加任意的方法和域,并实现任意的接口四、将不同行为与枚举中的每个常量关联...
  • Java枚举 自增赋值

    2021-02-12 23:58:38
    java中enum并没那么智能,是从0开始自增的。可以维护一个static变量实现任意自增:import java.util.EnumSet;public class EnumTest {public static void main(String[] args) {for (MSG_TYPE msg_type : EnumSet....
  • C++的int枚举互相转换使用强制类型转换即可,但在Java中从int构造Enum需要自己实现(不过如果枚举值从0开始递增就简单了,参考第二段代码)。自定义枚举值代码如下:==============================代码的分割线====...
  • 1、背景使用Mybatis存储枚举类型,数据库中以int类型存储,需要进行类型转换(handler适配)2、代码实现枚举类定义:public interface IEnum{int getValue();}public enum EnumWhatIfChangeType implements IEnum{/***...
  • import java.lang.reflect.Method;import java.util.LinkedHashMap;import java.util.Map;import org.apache.commons.lang3.reflect.MethodUtils;/*** 功能:枚举使用工具* 作者:Gary Huang* 日期: 2014-3...
  • 比较Java枚举

    2021-02-12 10:14:55
    Java枚举已经内置了compareTo(..)方法,该方法使用枚举位置(也称为序数)将一个对象与另一个对象进行比较。 根据声明枚举常量的顺序确定位置,其中第一个常数的序数为零。如果这种安排不合适,则可能需要通过添加内部...
  • 框架SpringBoot MyBatis TypeHandler主要使用mybatis中的TypeHandler接口在java中使用如下枚举:public enum Status {DELETED(-1, "已删除"),NORMAL(1, "正常");private final int code;private final String text;...
  • Enum作为Sun全新引进的一个关键字,看起来很象是特殊的class, 它也可以有自己的变量,可以定义自己的方法,可以实现一个或者多个接口。 当我们在声明一个enum类型时...2.所有枚举值都是public , static , final的。...
  • java枚举接口

    2021-03-04 02:42:08
    java中的枚举类枚举类(enum),与class和interface关键字地位相同。枚举类是一个特殊的类,可以有自己的成员变量、方法、构造器,可以实现一个或...文章云栖-lxl2015-03-06458浏览量Java枚举Java枚举有如下特点:枚举...
  • JAVA枚举

    2021-03-17 12:45:35
    一、什么是枚举枚举是由一组固定的常量组成的合法值。通过这一定义,我们可以看出枚举...二、枚举的优势我们经常会定义存放常量的类,里面有一些int常量(通常叫int枚举)。比如:public static final int STATE_BEG...
  • Java枚举教程我们已经了解了Java枚举详解语法[public] enum 枚举类型名称{枚举对象1,枚举对象2,枚举对象3...枚举对象n;}参数参数描述[public]可选字段,表示枚举范围enum定义枚举的关键字枚举类型名称和类名一样,...
  • 如何在Java中将String转换为枚举

    千次阅读 2021-03-13 18:54:52
    Java中Enum类的valueOf()方法接受一个String值,并返回一个指定类型的枚举常量。示例让我们创建一个名称为Vehicles的枚举,其中包含5个常量,代表5个不同scoters的模型,其价格为值,如下所示-enumVehicles{//带值的...
  • java 枚举

    2021-03-13 03:56:21
    Java枚举的线程安全性及序列化问题--枚举是如何保证线程安全的要想看源码,首先得有一个类吧,那么枚举类型到底是什么类呢?是enum吗?答案很明显不是,enum就和class一样,只是一个关键字,他并不是一个类,那么...
  • 对于:enum Color {RED,BLUE,BLACK YELLOW,GREEN};(1) ordinal()方法: 返回枚举值在枚举类种的顺序。这个顺序根据枚举值声明的顺序而定。... //返回结果:1(2) compareTo()方法: Enum实现了java.lang.Comparab...
  • Enum枚举类型Enum的全写是Enumeration,这个词的翻译是列举、...Java中的枚举枚举前时代在Java语言中, 枚举类型从JDK1.5才开始提供。在这之前使用接口静态常量来实现相关功能(也可以是类静态常量),以季节为例:...
  • java 枚举类型分析

    2021-02-12 20:49:02
    最近做android开发,需要用到枚举值,这样可以连续赋值,我按之前c++那样书写,如下所示:public enumColorSelect {RED_BAGE= 0,GREEN_BAGE,BLUE_BAGE;}编译不过。我将赋值语句修改了以后,如下所示:public ...
  • java枚举泛型

    2021-02-12 18:40:48
    泛型和枚举都是JDK1.5版本之后加入的新特性,泛型将程序代码的类型检查提前到了编译期间进行,枚举类型增强了程序代码的健壮性。1. 泛型在JDK1.5版本之前,如果在集合中添加了不同类型的数据,需要在程序的运行期间...
  • Java枚举的几种操作方法

    千次阅读 2021-02-12 14:08:57
    枚举其实就是一种类型,跟int, char 这种差不多,就是定义变量时限制输入的,你只能够赋enum里面规定的值。定义枚举 方法很简单,就跟定义一个类一样,只是把class换成 enum,其他的,你懂地。e.g:public enum ...
  • 先说说简单的枚举类型,与字符串,整型之间的转换。可以理解为,枚举,就是一个简单的数组public enum Weather {winter,spring,summer,fall}public class EnumDemo {public ...//枚举转换整型int winter = Weat...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 171,366
精华内容 68,546
关键字:

java枚举转int

java 订阅