All 15 Enums questions
More in Enums
How do you retrieve all constants of an enum type, and how would you iterate over them? How do you add fields, constructors, and methods to a Java enum, and how would you implement an enum representing planets with mass and radius that calculates surface gravity? How does the EnumSet and EnumMap provide more efficient alternatives to HashSet<Enum> and HashMap<Enum, V> specifically for enum keys? How would you implement an enum that also implements an interface, and what's the benefit of having different enum constants provide different behavior through a shared interface contract? How do you correctly use an enum as a switch statement/expression's target, and what changed with the introduction of arrow-style switch expressions (Java 14+) regarding exhaustiveness and fall-through? What is the valueOf() method on an enum, and what happens when you pass a name that doesn't match any declared constant? How would you use an enum to represent a fixed set of configuration keys combined with a shared lookup method, avoiding scattered String literal keys throughout a codebase? How would you implement the Strategy pattern using an enum with constant-specific method bodies, and how does this compare to a traditional interface-based Strategy implementation? How does Java implement enums under the hood at the bytecode level (extending java.lang.Enum), and what makes them inherently thread-safe and serialization-safe as singletons? How would you use an EnumMap combined with a switch expression to implement a state machine, and what compile-time safety benefits does an exhaustive switch over an enum provide?
Advertisement
Java › Enums

What are the ordinal() and name() methods on an enum constant, and why is relying on ordinal() for persistence or serialization considered dangerous?

Intermediate

Answer

ordinal() returns the zero-based position of a constant in its enum's declaration order, and name() returns the constant's declared identifier as a String -- persisting an enum's ordinal() value (e.g., storing it in a database) is dangerous because ordinal values are entirely dependent on declaration order, meaning simply reordering, inserting, or removing a constant in the enum's source code (a seemingly harmless refactor) silently changes the meaning of every previously-persisted ordinal value, causing data corruption without any compiler warning; persisting name() instead is far safer since it's tied to the constant's actual identifier rather than its fragile positional order (though renaming a constant would still require a data migration, that's a much rarer and more deliberate change than reordering).
enum Priority { LOW, MEDIUM, HIGH }  // ordinals: LOW=0, MEDIUM=1, HIGH=2

// DANGEROUS: persisting ordinal()
int stored = Priority.HIGH.ordinal();  // stores 2

// If someone later reorders the enum to: LOW, HIGH, MEDIUM
// then ordinal 2 now means MEDIUM instead of HIGH -- silent data corruption!

// SAFER: persist name() instead
String stored2 = Priority.HIGH.name();  // stores "HIGH", immune to reordering
Real-world example A team debugging why historical order priority data appeared to have silently changed meaning after a routine code refactor discovers the database had been storing Priority.ordinal() values, and a well-intentioned enum reordering during an unrelated change had silently invalidated the meaning of every previously stored value, prompting a migration to storing name() instead.

Common follow-ups: What's the safest approach if you need a genuinely stable, explicit persisted value that's independent of both ordinal and name (like an explicit numeric code field)?;Why does Comparable's compareTo() implementation for enums use ordinal() despite this same fragility concern?

equals() hashCode() & toString() Contracts;Serialization & Deserialization
All 15 Enums questions