What is the difference between `Enum.name()` and `Enum.toString()`?

java

enum-methods

java-best-practices

enum-usage

byAlex Kataev·Mar 11, 2025

**`Enum.name()`** is constant, gives the declared identifier of the enum constant. **`Enum.toString()`** also returns the declared name by default but can be *jumbotroned* with your handy code.

```java
enum Quirk { NEEDED_COFFEE, CODE_COMPILING }

// Just its name, chillin'
Quirk.NEEDED_COFFEE.name(); // "NEEDED_COFFEE"

// Chameleon, changes as you wish
Quirk.CODE_COMPILING.toString(); // "CODE_COMPILING" (unless you 'enhance' it in your codebase)

The nitty-gritty details

An enum in Java is a special type that represents a fixed set of constants. To grasp its method's intentions, buckle up, as we dive deep down the rabbit hole!

Enum.name(): A constant companion

Enum.name() is a final method, it's rock solid. It echoes the precise name declared in the enum constant. Think of it as your immutable best friend, always reliable, never lets you down.

Enum.toString(): The chameleon of methods

Contrary, Enum.toString(), the cool kid on the block, is highly adaptable. By default, it'll return the declared name but you can override it to display as you fancy.

Interactions and implications

These aren't just methods hugging in an enum, they are essential gears powering real-world applications. Let's get acquainted with their roles and possible pitfalls:

Enum.name() in logic land

If Enum.toString() dipped its toes in critical code logic, it could sprinkle some surprise bugs. It's like that clumsy friend who's fun at parties but shouldn't handle delicate china. For solid, consistent value, give a high-five to Enum.name()!

Enum.toString() in display paradise

Here's where the adaptable Enum.toString() really shines. When your enum needs a greeting on a user interface, or wants to walk the fashion ramp in your logs, Enum.toString() has the wardrobe ready.

Enum.name() the bearer of persistence

Now, Enum.name() plays a vital role when dealing with data persistence. It ensures your enum values survived time travel via DB or file unchanged. On the contrary, Enum.toString() can add a twist in the tale if its representation is altered.

Enum.toString() the illusionist

Deck up your enum's appearance per context - a confounding illusion? Nope, simply override Enum.toString(). Ideal for applications seeking localization or runtime configured displays.

Reincarnating Enums

The Enum.valueOf() helps reconstruct enum from String. Using the name() is always safe, while using the shape-shifting toString() leads to problems faster than a greased weasel.

Know who you are with Enum.name()

WeekDay.valueOf(WeekDay.MONDAY.name()) works because name() is as stable as a sumo wrestler. Even amidst changing toString() versions.

toString() can throw a party

WeekDay.valueOf(WeekDay.MONDAY.toString()) might throw an IllegalArgumentException, mainly if toString() had a bad day and decided to change.

Tips and tricks (and traps!)

Let's unwrap some goodies that prevent bugs and bolster your coding armory.

Case sensitive conundrum

The Enum.valueOf() method is sensitive to cases, unlike a cuddly panda. Be wary of toString() causing runtime errors if not showing case consistency.

Careful overriding toString()

Feels powerful overriding toString(), right? Just remember to document these changes in your code comments. Think of it as a surprise party warning note for the next developer.

explain-codes / Java / What is the difference between `Enum.name()` and `Enum.toString()`?

Linked

Best way to create enum of strings?



Where is the documentation for the `values()` method of Enum?



What are enums and why are they useful?



Can enums be subclassed to add new elements?



Coding Conventions - Naming Enums

