Comparación de enum en Java: ¿== o equals()? Detalles que no se cuentan

Introducción: El error que quizás estás cometiendo ahora mismo

Imagina la situación: estás programando en Java, usas enumeraciones (enum) y necesitas comparar dos valores. Automáticamente escribes if (day == Day.MONDAY). O quizás, if (day.equals(Day.MONDAY)). ¿Y cuál es la opción correcta? ¿Acaso hay alguna diferencia?

Esta pregunta es una de las más populares en Stack Overflow. Miles de desarrolladores (desde principiantes hasta seniors) se la han hecho. Parece un detalle menor. Pero detrás de este "detalle" se esconde una comprensión profunda de cómo funciona la JVM, cómo están construidos los enum y por qué en Java no todo es tan sencillo.

En este artículo, de una vez por todas, aclararemos: cómo comparar correctamente enum en Java, cuándo usar == y cuándo equals(), y por qué una de estas opciones es casi siempre la mejor elección.

Respuesta corta para los impacientes

Si necesitas la respuesta ahora mismo — usa ==.

¡Pero! Antes de que cierres el artículo, analicemos por qué es así y qué trampas te pueden esperar. Porque el diablo, como siempre, está en los detalles.

¿Por qué enum no es solo un conjunto de constantes?

Para entender la diferencia entre == y equals(), debemos recordar qué es realmente un enum en Java.

Cada enum es una clase completa que hereda implícitamente de java.lang.Enum. Cada constante de enum es una instancia final estática de esta clase. La JVM garantiza que para cada valor de enum existe exactamente un objeto en memoria.

Mira este código:

public enum Day {\n    MONDAY,\n    TUESDAY,\n    WEDNESDAY,\n    THURSDAY,\n    FRIDAY,\n    SATURDAY,\n    SUNDAY\n}

Cuando la JVM carga este enum, crea exactamente 7 objetos. Day.MONDAY es siempre el mismo objeto. Siempre. Y este es el punto clave.

Comparación con ==: ¿Por qué funciona?

El operador == en Java compara referencias a objetos. No mira el contenido — verifica si dos variables apuntan al mismo objeto en memoria.

Dado que la JVM garantiza la unicidad de cada instancia de enum, la comparación con == para enum funciona perfectamente:

public class EnumComparison {\n    public static void main(String[] args) {\n        Day today = Day.WEDNESDAY;\n        Day anotherDay = Day.WEDNESDAY;\n        \n        // Ambas variables referencian el mismo objeto en memoria\n        System.out.println(today == anotherDay); // true\n        \n        // Comparación con otra constante\n        System.out.println(today == Day.MONDAY); // false\n    }\n}

Salida:

true\nfalse

Todo es simple y elegante. Pero veamos qué sucede bajo el capó.

¿Por qué es seguro? Garantías de la JVM

La Especificación del Lenguaje Java (JLS 8.9) garantiza que cada valor de enum se inicializa exactamente una vez al cargar la clase. No podrás crear un duplicado mediante reflexión, serialización o clonación. Incluso si intentas usar new, el compilador dará un error.

Por lo tanto, == para enum no es solo que "funciona", es la forma más rápida y confiable de comparación.

Comparación con equals(): Funciona, pero tiene matices

El método equals() también funciona. La clase Enum sobrescribe equals() y, internamente, usa ==:

// Código real de java.lang.Enum\npublic final boolean equals(Object other) {\n    return this == other;\n}

Es decir, llamar a day.equals(Day.MONDAY) termina haciendo lo mismo que day == Day.MONDAY. Pero hay una diferencia importante:

El problema con null

Si tu variable puede ser