Comparer les valeurs Java enum

Toutes les énumérations Java implémentent Comparable: http://java.sun.com/javase/6/docs/api/java/lang/Enum.html

Vous pouvez également utiliser la méthode ordinal pour les transformer en int . La comparaison est alors sortingviale.

 if (ErrorLevel.ERROR.compareTo(someOtherLevel) <= 0) { ... } 

Une version beaucoup plus expressive serait

 myError.isErrorOrAbove(otherError) 

ou

 myError.isWorseThan(otherError) 

De cette façon, vous pouvez définir l’ordre dans l’Enum et modifier l’implémentation en interne si vous le souhaitez. Désormais, les clients de l’Enum peuvent comparer des valeurs sans connaître aucun détail à ce sujet.

Une mise en œuvre possible serait

 public enum ErrorLevel { INFO(0), WARN(1), ERROR(2), FATAL(3); private Integer severity; ErrorLevel(int severity) { this.severity = severity; } public boolean isWorseThan(ErrorLevel other) { return this.severity > other.severity; } } 

Je ne recommanderais pas non plus l’utilisation de la méthode ordinal () à des fins de comparaison, car lorsqu’une personne modifie l’ordre dans lequel les valeurs Enum sont définies, le comportement peut être inattendu.

En supposant que vous les avez définies par ordre de gravité, vous pouvez comparer les ordinaux de chaque valeur. L’ordinal est sa position dans sa déclaration enum, où la constante initiale se voit atsortingbuer un ordinal égal à zéro.

Vous obtenez l’ordinal en appelant la méthode ordinal () de la valeur.

Je veux vérifier si un niveau d’erreur est “erreur ou plus”.

Une telle énumération devrait avoir un niveau associé. Donc, pour trouver des égaux ou plus, comparez les niveaux.

L’utilisation de l’ordinal repose sur l’ordre dans lequel les valeurs enum apparaissent. Si vous comptez sur cela, vous devriez le documenter sinon une telle dépendance peut conduire à un code fragile.

Java enum a déjà construit la méthode compareTo (..) , qui utilise la position enum (ou ordinal) pour comparer un object à un autre. La position est déterminée en fonction de l’ordre dans lequel les constantes d’ énumération sont déclarées, la première constante étant affectée d’un ordinal égal à zéro.
Si cet arrangement ne vous convient pas, vous devrez peut-être définir votre propre comparateur en ajoutant un ou plusieurs champs internes, comme indiqué ci-dessous:

 import java.util.Comparator; public enum Day { MONDAY(1, 3), TUESDAY(2, 6), WEDNESDAY(3, 5), THURSDAY(4, 4), FRIDAY(5, 2), SATURDAY(6, 1), SUNDAY(0, 0); private final int calendarPosition; private final int workLevel; Day(int position, int level) { calendarPosition = position; workLevel = level; } int getCalendarPosition(){ return calendarPosition; } int getWorkLevel() { return workLevel; } public static Comparator calendarPositionComparator = new Comparator() { public int compare(Day d1, Day d2) { return d1.getCalendarPosition() - d2.getCalendarPosition(); } }; public static Comparator workLevelComparator = new Comparator() { public int compare(Day d1, Day d2) { // descending order, harder first return d2.getWorkLevel() - d1.getWorkLevel(); } }; } 

Pilote pour vérifier si tout fonctionne:

 import java.util.Arrays; import java.util.Collections; import java.util.List; public class EnumTest { public static void main (Ssortingng[] args) { List allDays = Arrays.asList(Day.values()); System.out.println("===\nListing days in order of calendar position:"); Collections.sort(allDays, Day.calendarPositionComparator); showItems(allDays); System.out.println("===\nListing days in order of work level:"); Collections.sort(allDays, Day.workLevelComparator); showItems(allDays); } public static void showItems(List days) { for (Day day : days) { System.out.println(day.name()); } } } 

Une autre option serait

 enum Blah { A(false), B(false), C(true); private final boolean isError; Blah(boolean isErr) {isError = isErr;} public boolean isError() { return isError; } } 

D’après votre question, je suppose que vous utilisez enum pour désigner une sorte de valeur de retour, dont certains sont des états d’erreur. Cette implémentation présente l’avantage de ne pas avoir à append les nouveaux types de retour à un endroit particulier (puis à ajuster la valeur de votre test), mais présente l’inconvénient de nécessiter un travail supplémentaire pour l’initialisation de l’énumération.

Poursuivant mon hypothèse un peu plus loin, les codes d’erreur sont-ils pour l’utilisateur? Un outil de débogage? Si c’est le dernier cas, j’ai trouvé que le système de gestion des exceptions fonctionnait bien pour Java.