Comparer les valeurs enum de Java

Est-il un moyen de vérifier si une valeur d'enum est "supérieur ou égal" à une autre valeur?

Je veux vérifier si un niveau d'erreur est une erreur ou d'en haut".

InformationsquelleAutor ripper234 | 2009-07-19

54

Tous Java enums implémente Comparable: http://java.sun.com/javase/6/docs/api/java/lang/Enum.html

Vous pouvez également utiliser le ordinal méthode pour les transformer en ints, alors la comparaison est trivial.
```
if (ErrorLevel.ERROR.compareTo(someOtherLevel) <= 0) {
  ...
}
```
- Ce n'est pas vraiment un enum, apparemment. Mais il a une méthode 'isGreaterOrEqual()'
- Votre question dit "enum"
- Le message de docs.oracle.com/javase/7/docs/api/java/lang/... est: "L'ordre naturel mis en œuvre par cette méthode est l'ordre dans lequel les constantes sont déclarées". Ainsi, enum { TRACE, DEBUG, INFO, WARN } signifie: TRACE < DEBUG < INFO < AVERTIR.
InformationsquelleAutor Chris Vest
26

Une version qui est beaucoup plus expressif serait
```
myError.isErrorOrAbove(otherError)
```
ou
```
myError.isWorseThan(otherError)
```
De cette façon, vous pouvez définir l'ordre à l'intérieur de l'Enum et peut changer la mise en œuvre en interne si vous le souhaitez. Maintenant, les clients de l'Enum peut comparer les valeurs sans en connaître tous les détails à ce sujet.

Une possible mise en œuvre doit être
```
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 voudrais aussi ne recommandons pas l'utilisation de l'ordinal() méthode pour la comparaison, parce que quand quelqu'un change de l'ordre de l'énumération des valeurs définies, vous pourriez obtenir un comportement inattendu.
- D'accord. En s'appuyant sur les positions ordinales est une énorme erreur et pourrait entraîner certains très difficiles à traquer les bugs.
InformationsquelleAutor Felix Reckers
8

En supposant que vous avez définie dans l'ordre de gravité, vous pouvez comparer les ordinaux de chaque valeur. L'ordinal est sa position dans sa déclaration d'enum, où la première constante est attribué un nombre de zéro.

Vous obtenez l'ordinal par l'appel de la ordinal() la méthode de la valeur.

InformationsquelleAutor Rich Seller
5

Je veux vérifier si un niveau d'erreur est une erreur ou d'en haut".

Une enum doit avoir un niveau associé. Afin de trouver supérieure ou égale vous conseillons de comparer les niveaux.

À l'aide de ordinale s'appuie sur l'ordre de l'énumération des valeurs apparaissent. Si vous comptez sur ce que vous devriez document autrement une telle dépendance peut conduire à une fragilité code.

InformationsquelleAutor Peter Lawrey

Java enum a déjà construit dans compareTo(..) méthode, qui utilise le protocole enum position (aka ordinal) pour comparer un objet à l'autre. La position est déterminée en fonction de l'ordre dans lequel les enum constantes sont déclarées
où la première constante est attribué un nombre de zéro.

Si cet arrangement est pas approprié, vous pouvez avoir besoin pour vous définir propre comparateur de par l'ajout du champ interne(s) 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<Day> calendarPositionComparator = new Comparator<Day>() {
    public int compare(Day d1, Day d2) {
      return d1.getCalendarPosition() - d2.getCalendarPosition();
    }
  };

  public static Comparator<Day> workLevelComparator = new Comparator<Day>() {
    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 (String[] args) {
     List<Day> 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<Day> days) {
    for (Day day : days) {
      System.out.println(day.name());
    }
  }
}

InformationsquelleAutor MaxZoom

1

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; }
}
```
De votre question, je suis en supposant que vous êtes en utilisant un enum pour désigner une sorte de valeur de retour, dont certaines sont des états d'erreur. Cette mise en place a l'avantage de ne pas devoir ajouter de nouveaux types de retour dans un lieu particulier (et ensuite ajuster votre test de valeur), mais a l'inconvénient d'avoir besoin d'un travail supplémentaire dans l'initialisation de l'enum.

De poursuivre mon hypothèse un peu plus loin, sont des codes d'erreur de quelque chose pour l'utilisateur? Un outil de débogage? Si c'est le dernier, que j'ai trouvé à l'exception du système de manipulation à être assez bien pour Java.

InformationsquelleAutor Carl

Vous devez vous connecter pour publier un commentaire.