Working with Enums in android

Question

I am almost done with a calculation activity I am working with in android for my app. I try to create a Gender Enum, but for some reason getting Syntax error, insert "EnumBody" to complete EnumDeclaration.

public static enum Gender
{
    static
    {
        Female = new Gender("Female", 1);
        Gender[] arrayOfGender = new Gender[2];
        arrayOfGender[0] = Male;
        arrayOfGender[1] = Female;
        ENUM$VALUES = arrayOfGender;
    }
}

I have also tried it without the static {} but I get the same syntax error.

Enums are not recommended for performance issues, use primitive constants instead. https://www.youtube.com/watch?v=Hzs6OBcvNQE — Myke Dev, Oct 16 '15 at 19:43
UPDATE 2019: Enums are fine to use in Android since ART replaced DALVIK as runtime environment https://stackoverflow.com/a/56296746/4213436. Therefore I think most answers on this thread are irrelevant. — JDenais, Sep 20 '19 at 08:20
@JDenais of course you mean the thread 'you' just referenced — YoussefDir, Apr 09 '20 at 17:31

Spidy · Accepted Answer · 2012-02-12T06:52:31.797

371

Where on earth did you find this syntax? Java Enums are very simple, you just specify the values.

public enum Gender {
   MALE,
   FEMALE
}

If you want them to be more complex, you can add values to them like this.

public enum Gender {
    MALE("Male", 0),
    FEMALE("Female", 1);

    private String stringValue;
    private int intValue;
    private Gender(String toString, int value) {
        stringValue = toString;
        intValue = value;
    }

    @Override
    public String toString() {
        return stringValue;
    }
}

Then to use the enum, you would do something like this:

Gender me = Gender.MALE

edited Feb 12 '12 at 06:52

answered Feb 12 '12 at 06:34

Spidy

39,723
15
65
83

16

I will give that a try, I did say I was an absolute beginner – JMSDEV Feb 12 '12 at 07:02
92

Sorry, I didn't mean that negatively. Just the weirdest syntax I've ever seen for an Enum – Spidy Feb 12 '12 at 07:15
4

Its also helpful to mention enums are sequential so you can use .ordinal() on the enum to get the int value. – Kalel Wade Apr 25 '14 at 20:24
1

The syntax in the question is the kind one might come up with from using a decompiler. – Dan Getz Jun 08 '16 at 20:26
11

I laughed so much on "Where on earth did you find this syntax" . Saying just like a teacher to his student – Zar E Ahmer Aug 10 '16 at 07:34
where on earth hahahahahaha – SahdevRajput74 Nov 27 '17 at 11:38
how to get String by use "Gender.Male"? – roghayeh hosseini May 15 '19 at 10:13
@roghayehhosseini Gender.Male.toString() – Spidy May 15 '19 at 17:25
This is a good post because I was adding comments to some code that uses enum and it reminded me that an enum seems to be a "class" even though you don't use the word class when you define it. – dcarl661 Mar 13 '20 at 17:44
For an easier syntax, check this https://stackoverflow.com/a/8157790/4373371 – YoussefDir Apr 17 '20 at 23:10

score 50 · Answer 2 · answered Oct 03 '14 at 08:06

There has been some debate around this point of contention, but even in the most recent documents android suggests that it's not such a good idea to use enums in an android application. The reason why is because they use up more memory than a static constants variable. Here is a document from a page of 2014 that advises against the use of enums in an android application. http://developer.android.com/training/articles/memory.html#Overhead

I quote:

Be aware of memory overhead

Be knowledgeable about the cost and overhead of the language and libraries you are using, and keep this information in mind when you design your app, from start to finish. Often, things on the surface that look innocuous may in fact have a large amount of overhead. Examples include:

Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android.

Every class in Java (including anonymous inner classes) uses about 500 bytes of code.

Every class instance has 12-16 bytes of RAM overhead.

Putting a single entry into a HashMap requires the allocation of an additional entry object that takes 32 bytes (see the previous section about optimized data containers).

A few bytes here and there quickly add up—app designs that are class- or object-heavy will suffer from this overhead. That can leave you in the difficult position of looking at a heap analysis and realizing your problem is a lot of small objects using up your RAM.

There has been some places where they say that these tips are outdated and no longer valuable, but the reason they keep repeating it, must be there is some truth to it. Writing an android application is something you should keep as lightweight as possible for a smooth user experience. And every little inch of performance counts!

_There has been some places_ - could you add some if you know them? because I can't find any — Krzysztof Skrzynecki, Apr 22 '15 at 15:07
[Here](http://stackoverflow.com/q/5143256/2004186) somebody noticed that information about using ints instead of enums was removed from [Performance Tips](http://developer.android.com/training/articles/perf-tips.html#avoid_enums) in official documentation. Moreover, I've made research and posted [summary on reddit](http://redd.it/33hct2) — Krzysztof Skrzynecki, Apr 23 '15 at 08:34
Android Performance Patterns: [The price of ENUMs (100 Days of Google Dev)](https://www.youtube.com/watch?v=Hzs6OBcvNQE) — Afriza N. Arief, Nov 04 '15 at 06:56
Guys, my question is if Enum is "bad" practice, why does Google still support this feature of Java with Android? :( — Jesús Castro, Nov 06 '15 at 23:01
@JesúsCastro Because Google wants to ensure that companies with lots of existing Java business logic (which may be using enums) can just drop their library into an Android project and go. — David Brown, Jan 28 '16 at 16:36

score 24 · Answer 3 · edited May 23 '17 at 12:18

As commented by Chris, enums require much more memory on Android that adds up as they keep being used everywhere. You should try IntDef or StringDef instead, which use annotations so that the compiler validates passed values.

public abstract class ActionBar {
...
@IntDef({NAVIGATION_MODE_STANDARD, NAVIGATION_MODE_LIST, NAVIGATION_MODE_TABS})
@Retention(RetentionPolicy.SOURCE)
public @interface NavigationMode {}

public static final int NAVIGATION_MODE_STANDARD = 0;
public static final int NAVIGATION_MODE_LIST = 1;
public static final int NAVIGATION_MODE_TABS = 2;

@NavigationMode
public abstract int getNavigationMode();

public abstract void setNavigationMode(@NavigationMode int mode);

It can also be used as flags, allowing for binary composition (OR / AND operations).

EDIT: It seems that transforming enums into ints is one of the default optimizations in Proguard.

I like to place int constants directly into annotation class. Thus it looks like regular enum. I described it here: http://blog.shamanland.com/2016/02/int-string-enum.html — Oleksii K., Feb 07 '16 at 14:30

score 18 · Answer 4 · answered Feb 12 '12 at 06:33

18

public enum Gender {
    MALE,
    FEMALE
}

answered Feb 12 '12 at 06:33

Gabriel Negut

13,860
4
38
45

score 10 · Answer 5 · answered Dec 28 '15 at 15:14

10

According to this Video if you use the ProGuard you don't need even think about Enums performance issues!!

Proguard can in many situations optimize Enums to INT values on your behalf so really don't need to think about it or do any work.

answered Dec 28 '15 at 15:14

Hani

1,430
15
17

score 5 · Answer 6 · answered Apr 21 '17 at 23:27

Android's preferred approach is int constants enforced with @IntDef:

public static final int GENDER_MALE = 1;
public static final int GENDER_FEMALE = 2;

@Retention(RetentionPolicy.SOURCE)
@IntDef ({GENDER_MALE, GENDER_FEMALE})
public @interface Gender{}

// Example usage...
void exampleFunc(@Gender int gender) {
  switch(gender) {
  case GENDER_MALE:

     break;
  case GENDER_FEMALE:
     // TODO
     break;
  }
}

Docs: https://developer.android.com/studio/write/annotations.html#enum-annotations

Working with Enums in android

6 Answers6

Linked