Last Updated: 

Converting Enum to Int in Java

In Java, enums are a special data type that allow you to define a set of named constants. There are often situations where you need to convert an enum value to an integer. This conversion can be useful for various purposes, such as serialization, database storage, or when working with legacy systems that expect integer values. In this blog post, we will explore the core concepts, typical usage scenarios, common pitfalls, and best practices related to converting enums to integers in Java.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Code Examples
  4. Common Pitfalls
  5. Best Practices
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

Enum in Java#

An enum in Java is a special class that represents a group of constants. Each enum constant is an instance of the enum class. For example:

enum Color {
    RED, GREEN, BLUE;
}

Here, Color is an enum class, and RED, GREEN, and BLUE are its enum constants.

Enum's ordinal() Method#

Every enum in Java has an implicit ordinal() method. This method returns the position of the enum constant in its enum declaration, starting from 0. For example, for the Color enum above, Color.RED.ordinal() will return 0, Color.GREEN.ordinal() will return 1, and Color.BLUE.ordinal() will return 2.

Custom Integer Values#

You can also assign custom integer values to enum constants. This is done by defining a private field and a constructor in the enum class. For example:

enum Status {
    ACTIVE(1), INACTIVE(0);
 
    private final int value;
 
    Status(int value) {
        this.value = value;
    }
 
    public int getValue() {
        return value;
    }
}

Here, ACTIVE has a custom integer value of 1, and INACTIVE has a value of 0.

Typical Usage Scenarios#

Database Storage#

When storing enum values in a database, it is often more efficient to store them as integers rather than strings. For example, if you have an OrderStatus enum with values like PENDING, PROCESSING, and COMPLETED, you can store the corresponding integer values in the database.

Serialization#

In some serialization scenarios, it may be necessary to convert enum values to integers. For example, when sending data over a network, sending integer values is more compact than sending string representations of enums.

Legacy System Integration#

If you are integrating with a legacy system that expects integer values, you may need to convert enum values to integers before passing them to the system.

Code Examples#

Using ordinal() Method#

// Define an enum
enum Weekday {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}
 
public class EnumToIntExample {
    public static void main(String[] args) {
        // Get an enum constant
        Weekday day = Weekday.MONDAY;
 
        // Convert enum to int using ordinal()
        int dayNumber = day.ordinal();
 
        System.out.println("The ordinal value of " + day + " is: " + dayNumber);
    }
}

Using Custom Integer Values#

// Define an enum with custom integer values
enum Priority {
    LOW(1), MEDIUM(2), HIGH(3);
 
    private final int value;
 
    Priority(int value) {
        this.value = value;
    }
 
    public int getValue() {
        return value;
    }
}
 
public class CustomEnumToIntExample {
    public static void main(String[] args) {
        // Get an enum constant
        Priority priority = Priority.MEDIUM;
 
        // Convert enum to int using custom value
        int priorityValue = priority.getValue();
 
        System.out.println("The custom value of " + priority + " is: " + priorityValue);
    }
}

Common Pitfalls#

Relying on ordinal() for Persistence#

Using the ordinal() method for database storage or serialization can be risky. If you add or remove enum constants in the future, the ordinal values of existing constants may change, leading to data integrity issues.

Incorrect Custom Value Assignment#

When assigning custom integer values to enum constants, make sure the values are unique. Duplicate values can lead to unexpected behavior.

Best Practices#

Use Custom Integer Values for Persistence#

Instead of relying on the ordinal() method, it is better to assign custom integer values to enum constants for database storage and serialization. This ensures that the integer values remain stable even if the enum declaration changes.

Provide a Reverse Lookup Method#

If you are using custom integer values, it is a good practice to provide a reverse lookup method in the enum class. This allows you to convert an integer back to the corresponding enum constant. For example:

enum Size {
    SMALL(1), MEDIUM(2), LARGE(3);
 
    private final int value;
 
    Size(int value) {
        this.value = value;
    }
 
    public int getValue() {
        return value;
    }
 
    public static Size fromValue(int value) {
        for (Size size : values()) {
            if (size.getValue() == value) {
                return size;
            }
        }
        throw new IllegalArgumentException("No matching Size enum for value: " + value);
    }
}

Conclusion#

Converting enums to integers in Java is a common task with various usage scenarios. By understanding the core concepts, such as the ordinal() method and custom integer values, and being aware of the common pitfalls and best practices, you can effectively convert enums to integers and use them in real-world applications.

FAQ#

Q: Can I change the ordinal value of an enum constant?#

A: No, the ordinal value of an enum constant is determined by its position in the enum declaration and cannot be changed.

Q: What happens if I use the ordinal() method for database storage and then add a new enum constant?#

A: The ordinal values of existing enum constants may change, which can lead to data integrity issues in the database. It is better to use custom integer values for database storage.

Q: How can I convert an integer back to an enum constant?#

A: If you are using custom integer values, you can provide a reverse lookup method in the enum class, as shown in the best practices section.

References#

2025-10