Comparaison des enum en Java : == ou equals() ? Les subtilités qu'on ne vous dit pas

Introduction : L'erreur que vous commettez peut-être en ce moment

Imaginez la situation : vous codez en Java, vous utilisez des énumérations (enum) et vous devez comparer deux valeurs. Vous écrivez automatiquement if (day == Day.MONDAY). Ou peut-être if (day.equals(Day.MONDAY)). Quelle est la bonne option ? Et y a-t-il une différence ?

Cette question est l'une des plus populaires sur Stack Overflow. Des milliers de développeurs (des débutants aux seniors) se la sont posée. Cela semble un détail. Mais derrière ce « détail » se cache une compréhension profonde du fonctionnement de la JVM, de la structure des enum et des raisons pour lesquelles tout n'est pas si simple en Java.

Dans cet article, nous allons une fois pour toutes clarifier : comment comparer correctement les enum en Java, quand utiliser == et quand utiliser equals(), et pourquoi l'une de ces options est presque toujours le meilleur choix.

Réponse courte pour les impatients

Si vous avez besoin d'une réponse immédiate — utilisez ==.

Mais ! Avant de fermer l'article, comprenons pourquoi il en est ainsi et quels pièges peuvent vous attendre. Parce que le diable, comme toujours, se cache dans les détails.

Pourquoi un enum n'est-il pas simplement un ensemble de constantes ?

Pour comprendre la différence entre == et equals(), il faut se rappeler ce qu'est réellement un enum en Java.

Chaque enum est une classe à part entière qui hérite implicitement de java.lang.Enum. Chaque constante d'enum est une instance statique finale de cette classe. La JVM garantit qu'il existe exactement un objet en mémoire pour chaque valeur d'enum.

Regardez ce code :

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

Lorsque la JVM charge cet enum, elle crée exactement 7 objets. Day.MONDAY est toujours le même objet. Toujours. Et c'est le point clé.

Comparaison avec == : Pourquoi cela fonctionne-t-il ?

L'opérateur == en Java compare les références des objets. Il ne regarde pas le contenu — il vérifie si deux variables pointent vers le même objet en mémoire.

Puisque la JVM garantit l'unicité de chaque instance d'enum, la comparaison avec == pour les enum fonctionne parfaitement :

public class EnumComparison {\n    public static void main(String[] args) {\n        Day today = Day.WEDNESDAY;\n        Day anotherDay = Day.WEDNESDAY;\n        \n        // Les deux variables référencent le même objet en mémoire\n        System.out.println(today == anotherDay); // true\n        \n        // Comparaison avec une autre constante\n        System.out.println(today == Day.MONDAY); // false\n    }\n}

Résultat :

true\nfalse

Tout est simple et élégant. Mais regardons ce qui se passe sous le capot.

Pourquoi est-ce sûr ? Les garanties de la JVM

La spécification du langage Java (JLS 8.9) garantit que chaque valeur d'enum est initialisée exactement une fois lors du chargement de la classe. Aucune réflexion, sérialisation ou clonage ne peut créer un doublon. Même si vous essayez d'utiliser new — le compilateur générera une erreur.

Par conséquent, == pour les enum n'est pas seulement « ça marche », c'est la méthode de comparaison la plus rapide et la plus fiable.

Comparaison avec equals() : Ça marche, mais avec des nuances

La méthode equals() fonctionne aussi. La classe Enum redéfinit equals(), et en interne elle utilise == :

// Code réel de java.lang.Enum\npublic final boolean equals(Object other) {\n    return this == other;\n}

Autrement dit, l'appel day.equals(Day.MONDAY) fait finalement la même chose que day == Day.MONDAY. Mais il y a une différence importante :

Le problème avec null

Si votre variable peut êtr