Comment ne peut-on pas comparer les deux valeurs enum par '<'?

Si enum implémente Comparable alors pourquoi ne peux pas comparer avec < ou >?

public class Dream    
{
    public static void main(String... args)
    {
        System.out.println(PinSize.BIG == PinSize.BIGGER); //false
        System.out.println(PinSize.BIG == PinSize.BIG); //true
        System.out.println(PinSize.BIG.equals(PinSize.BIGGER));//false
        System.out.println(PinSize.BIG > PinSize.BIGGERER);//compilation error
        //can't be compared
        System.out.println(PinSize.BIG.toString().equals(PinSize.BIGGER));//#4
        PinSize b = PinSize.BIG ;
        System.out.println( b instanceof Comparable);//true
    }  
}
enum PinSize { BIG, BIGGER, BIGGERER };

Ce n'cette question a à voir avec le SCJP/OCPJP?
C'est dans les sujets d'examen. chapitre 1: Déclarations, d'Initialisation et de Cadrage * Développer du code qui déclare les classes (y compris le résumé et toutes les formes de classes imbriquées), les interfaces, et les énumérations, et comprend l'utilisation appropriée de l'emballage et de déclarations d'importation (y compris statique des importations). * Développer du code qui déclare, initialise, et utilise les primitives, les tableaux, les énumérations et les objets statiques, de l'instance, et les variables locales. Aussi, l'utilisation légale des identificateurs pour les noms de variables. education.oracle.com/pls/web_prod-plq-dad/...

InformationsquelleAutor Joe | 2012-10-25

43

Vous pouvez faire ceci:
```
PinSize.BIGGEST.ordinal() > PinSize.BIG.ordinal()  //evaluates to `true`
```
Bien sûr, en supposant que BIGGEST a été déclaré après BIG dans l'énumération. La valeur ordinale dans une énumération est implicitement liée à la déclaration de la commande, par défaut, la première valeur est la valeur attribuée à l' 0, la deuxième valeur 1 et ainsi de suite.

Donc, si yo déclaré l'énumération comme cela, les choses vont fonctionner:
```
public enum PinSize {
    SMALLEST,  //ordinal value: 0
    SMALL,     //ordinal value: 1
    NORMAL,    //ordinal value: 2
    BIG,       //ordinal value: 3
    BIGGER,    //ordinal value: 4
    BIGGEST;   //ordinal value: 5
}
```
- +1 Si vous aviez BIGGER il pourrait être ordinale 4. 😉
- Est-il correct de dire que PinSize.PLUS grand est une variable de référence, comme par exemple un int tableau [];?
- est une valeur d'enum, il n'est pas correct de le comparer avec un tableau. Et de toute façon, en Java, toutes les variables pointant vers les objets (y compris les énumérations, les tableaux) sont des références
- Ainsi en est-il correct de dire qu'il n'est pas possible d'utiliser "< " et " >' opérateurs parce que PinSize.PLUS grand est une référence (représente l'adresse en mémoire) et il n'y a pas de point de comparaison adresse de mémoire et c'est la même chose pour toutes les autres références (Object, String, int[], etc.)?
- à droite, vous ne pouvez pas comparer des références à l'aide de <, >. Ces opérateurs fonctionnent uniquement pour les types de base, comme int, float, etc. Pour la comparaison des références, utilisez la méthode compareTo() la mise en œuvre de Comparator si nécessaire.
- Je crois que je préfère le à l'aide de b1.compareTo(b2), plutôt que de comparer les résultats de ordinal(), compte tenu de l'Enum.ordinal javadoc: "la Plupart des programmeurs auront pas l'usage de cette méthode. Il est conçu pour une utilisation sophistiquée enum basé sur des structures de données, telles que EnumSet et EnumMap." Plus de la pensée sur ce, (mais pas le < / > cas particulier), Josh Bloch 2e ed l'article 31.
InformationsquelleAutor Óscar López
17

La mise en œuvre de Comparable n'est pas signifie que vous pouvez utiliser < ou >. Vous pouvez seulement utiliser ceux avec des valeurs numériques.

La mise en œuvre de Comparable signifie qu'il existe un compareTo() méthode. Essayez ceci:
```
System.out.println(PinSize.BIG.compareTo(PinSize.BIGGER));
```
La compareTo() méthode retourne un int qui est plus petit, égal ou plus grand que 0, en fonction de la valeur est "plus grande". Dans le cas de enum valeurs, la "taille" dépend de l'ordre de la valeur d'enum définitions.

InformationsquelleAutor Joachim Sauer
1

Les réponses fournies expliquer le problème, mais je voudrais ajouter mes idées, parce que je sens qu'ils ne répondent pas à la question "pourquoi on ne peut pas comparer avec < ou >"?. Le problème revient donc à comparer les références. PinSize.PLUS grand et PinSize.BIGGERER sont les variables de référence. Le même que ci-dessous:
```
String s;
int[] array;
MyObject myObject;
```
Ils représentent adresses dans la mémoire. Ce qui est plus, les énumérations sont des singletons, donc il y a toujours un objet du type spécifié. Parce que la ligne ci-dessous est autorisé et renvoie true.
```
System.out.println(PinSize.BIG == PinSize.BIG); //true
```
Essayer de vérifier si une adresse en mémoire est plus grand ou plus petit que l'autre adresse en mémoire est impossible. La mise en œuvre interface Comparable et compareTo() la méthode donne une chance de fournir votre propre manière de comparer les objets qui ne sont pas les adresses en mémoire.
```
System.out.println(PinSize.BIG > PinSize.BIGGERER); //not possible
```
InformationsquelleAutor MrKiller21

Vous devez vous connecter pour publier un commentaire.