The ordinal()
does what you want to do. This is an excerpt from the documentation:
Returns the ordinal of this enumeration constant (its position in its enum
declaration, where the initial constant is assigned an ordinal of zero). Most programmers will have no use for this method. It is designed for use by sophisticated enum-based data structures, such as EnumSet
and EnumMap
.
Josh Bloch in Effective Java 2nd Edition goes further to explain why using ordinal()
is a terrible idea. Here are some quotes, slightly edited:
Never derive a value associated with an enum from its ordinal; store it in an instance field instead. (Item 31: Use instance fields instead of ordinals) It is rarely appropriate to use ordinals to index arrays: use EnumMap
instead. The general principle is that application programmers should rarely, if ever, use Enum.ordinal
. (Item 33: Use EnumMap
instead of ordinal indexing)
Your "weird and long" way is precisely the prescription of Item 31.
Fortunately, Java is not C. A Java enum
is very powerful and flexible, supported by many library classes, and you should learn to embrace them instead of using ordinal()
.
Have a look at EnumMap
for example.
A specialized Map
implementation for use with enum
type keys. All of the keys in an enum
map must come from a single enum
type that is specified, explicitly or implicitly, when the map is created. Enum Maps are represented internally as arrays. This representation is extremely compact and efficient.
That is, instead of the following (which is perhaps what you wanted to do):
T[] arr = ...;
TK tk = ...;
T something = ...;
arr[tk.ordinal()] = something;
You can instead do:
Map<TK,T> map = new EnumMap<TK,T>(TK.class);
TK tk = ...;
T something = ...;
map.put(tk, something);
The book also covers another "traditional" (ab)use of enum
in C, i.e. bit fields (assigning powers of 2 to each constant etc). Well, for that Java has EnumSet
instead.