Comment bien comparer deux nombres Entiers en Java?

Je sais que si vous comparez un coffret primitif Entier avec une constante telle que:

Integer a = 4;
if (a < 5)

a sera automatiquement unboxed et la comparaison sera travail.

Cependant, ce qui se passe lorsque vous comparez deux en boîte Integers et souhaitez comparer les sexes ou supérieur/inférieur?

Integer a = 4;
Integer b = 5;

if (a == b)

Permettra de code ci-dessus résultat de la vérification pour voir si elles sont le même objet, ou d'une auto-unbox dans ce cas?

Ce sujet:

Integer a = 4;
Integer b = 5;

if (a < b)

Eh bien, ce qui s'est passé lorsque vous avez essayé? Qu'avez-vous observer?
Kiers: explicite de L'expérience ne pouvait réfuter, ne prouve pas que unboxing se produit. Si vous utilisez == au lieu de equals donne le résultat correct, cela peut être parce que la boîte contenant les numéros sont internés ou autrement réutilisés (comme une optimisation du compilateur, sans doute). La raison de poser cette question est de savoir ce qui se passe en interne, et non pas ce qui semble se passer. (Au moins, c'est pourquoi je suis ici.)

InformationsquelleAutor | 2009-10-03

266

Non, == entre Integer, Long, etc. vérifier de référence de l'égalité - c'est à dire
```
Integer x = ...;
Integer y = ...;

System.out.println(x == y);
```
cela permettra de vérifier si x et y reportez-vous à la même objet plutôt que l'égalité des objets.

Donc
```
Integer x = new Integer(10);
Integer y = new Integer(10);

System.out.println(x == y);
```
est garanti pour imprimer false. Un stage de "petits" autoboxed valeurs peut conduire à la délicate résultats:
```
Integer x = 10;
Integer y = 10;

System.out.println(x == y);
```
Cette impression sera true, en raison des règles de la boxe (JLS section 5.1.7). C'est toujours en référence à l'égalité, mais les références véritablement sont égalité.

Personnellement j'utiliserais:
```
if (x.intValue() == y.intValue())
```
ou
```
if (x.equals(y))
```
Le dernier est un peu moins efficace, il n'y a pas une surcharge pour Integer.equals(Integer) alors il aura à faire moment de l'exécution de la vérification de type, tandis que le premier utilise le fait que nous savons déjà que les deux objets sont Integers.

Heureusement, compareTo connaît les types, de sorte que:
```
if (x.compareTo(y) < 0)
```
doit encore être efficace. Bien sûr, c'est de la micro-optimisation territoire et vous devez utiliser le code que vous trouverez la plus claire, après s'être assurer qu'il est correct 🙂

Comme vous le dites, pour toute comparaison entre un wrapper type (Integer, Long etc) et un type numérique (int, long etc) de l'emballage du type de valeur est unboxed et le test est appliqué à la primitive valeurs impliquées.

Cela se produit dans le cadre de l'option binaire numérique de promotion (JLS section 5.6.2). Considérer chaque individu documentation de l'exploitant pour voir si elle est appliquée. Par exemple, à partir de la documentation pour == et != (JLS 15.21.1):

Si les opérandes d'une égalité
opérateur sont tous les deux de type numérique, ou
l'un est de type numérique et les autres
est convertible (§5.1.8) numérique
type binaire numérique de promotion est
effectuées sur les opérandes (§5.6.2).

et pour <, <=, > et >= (JLS 15.20.1)

Le type de chacun des opérandes d'une
la comparaison numérique de l'opérateur doit être
un type qui est convertible (§5.1.8) à
une primitive de type numérique, ou un
erreur de compilation se produit. Binaire
numérique de la promotion est effectuée sur la
opérandes (§5.6.2). Si le promu
type des opérandes est de type int ou long,
ensuite signé comparaison des entiers est
effectuées; si ce type est promu
float ou double, puis à virgule flottante
la comparaison est effectuée.

Remarque comment aucun de ce qui est considéré comme une partie de la situation où ni type est un type numérique.
- Est-il une raison pourquoi vouloir écrire x.compareTo(y) < 0 au lieu de x < y?
- Non pas que je peut immédiatement penser.
- Comme de Java 1.6.27+ il y a une surcharge sur est égal à l'Entier de la classe, de sorte qu'il doit être aussi efficace que d'appeler .intValue(). Il compare les valeurs de la primitive int.
- Comme @otterslide dit, ce n'est pas nécessaire dans Java 8 plus. La comparaison d'Entiers avec Entier est par la valeur par défaut.
- L'ajout d'une surcharge de ne pas changer le comportement de l'opérateur == si, ne serait-il? Je ne suis pas en mesure de tester en ce moment, mais je serais très surpris si cela avait changé.
InformationsquelleAutor Jon Skeet
41

== sera toujours l'objet de test de l'égalité. Il est facile de se laisser berner, cependant:
```
Integer a = 10;
Integer b = 10;

System.out.println(a == b); //prints true

Integer c = new Integer(10);
Integer d = new Integer(10);

System.out.println(c == d); //prints false
```
Vos exemples avec les inégalités de travail, car ils ne sont pas définis sur les Objets. Cependant, avec la == comparaison, l'objet, l'égalité sera toujours vérifiée. Dans ce cas, lorsque vous initialisez les objets à partir d'une boîte primitif, le même objet est utilisé (pour a et b). C'est un bon d'optimisation depuis la primitive de la boîte de classes sont immuables.
- J'ai pensé que c'était l'objet de l'égalité testé. J'ai eu quelques résultats bizarres. Dois-je le remplacer avec .equals()? Aussi, ne vous pensez que je dois laisser les inégalités qu'ils sont ou de le faire d'une autre manière?
- Il y a quelques non-évidente dans le cas de bord avec l'autoboxing. J'ai mon IDE (Eclipse) définir la couleur de tout ce qui est de l'onu encadré en rouge, cela m'a sauvé de bugs à quelques reprises. Si vous êtes à la comparaison de deux nombres Entiers, utiliser .d'égal à égal, si vous voulez faire de votre inégalités clair, écrire le casting de manière explicite: si ((int)c < (int)d) ... ; Vous pouvez également le faire: c.compareTo(d) < 0 // === c < d
- Et si vous changez le nombre de littéraux à 200, à la fois des tests d'impression false.
- ... sur la plupart des JVM implémentations, ce qui est. En fonction de la langue spec le résultat peut varier entre les implémentations.
- Je pense que c'est plus clair d'appeler cela une "référence à l'égalité" - de cette façon, il est évident que ce que vous voulez dire. Je serais normalement à comprendre "l'objet de l'égalité" pour signifier "le résultat de equals être appelé".
- +1 Jon 🙂 je pensais juste " N'est pas (c == d) la comparaison de la variable référence à l'objet?'
- Mais Integer a = 3000; Integer b = 3000; Système.out.println(a == b); //affiche false
- Pourriez-vous svp m'envoyer un lien qui explique quoi faire, afin d'obtenir la coloration de travail comme vous l'avez fait? 🙂 Merci beaucoup d'avance!
- Pour tout le monde à regarder la façon d'obtenir la coloration de travail: dans Eclipse frappé Ctrl+3 et de recherche pour Syntax coloring.
- Je pense que c'est clairement pas OK optimisation, depuis la il ne fonctionne que pour petits autoboxed primitives, et quel jeu de autoboxed primitives, il travaille pour varier d'une implémentation à une autre, ce qui rend votre code fragile.
- Attention, Integer c = Integer.valueOf(10); Integer d = Integer.valueOf(10); System.out.println(c == d); //prints TRUE Parce que valueOf utilise un cach de -127 à +127. Comme pour Longtemps.valueOf. Donc, ne comptez pas sur == sauf pour des Primitifs ou Enum
InformationsquelleAutor Adam Lewis
15

Depuis Java 1.7, vous pouvez utiliser Objets.est égal à:
```
java.util.Objects.equals(oneInteger, anotherInteger);
```
Retourne true si les arguments sont égaux les uns aux autres et faux
sinon. Par conséquent, si les deux arguments sont null, true est retourné
et si exactement un argument est null, false est retourné. Sinon,
l'égalité est déterminé en utilisant la méthode equals de la première
argument.
- Cela gère les valeurs null donc fait au plus simple. Merci!
InformationsquelleAutor Justas
10

== vérifie la référence à l'égalité, cependant lors de l'écriture d'un code comme:
```
Integer a = 1;
Integer b = 1;
```
Java est assez intelligent pour réutiliser le même immuable pour a et b, donc, c'est vrai: a == b. Curieux, j'ai écrit un petit exemple pour montrer où java s'arrête l'optimisation de cette façon:
```
public class BoxingLol {
    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            Integer a = i;
            Integer b = i;
            if (a != b) {
                System.out.println("Done: " + i);
                System.exit(0);
            }
        }
        System.out.println("Done, all values equal");
    }
}
```
Quand j'ai compiler et exécuter ce (sur ma machine), j'obtiens:
```
Done: 128
```
- tl;dr -1 pour handwaving ; stackoverflow.com/questions/15052216/... stackoverflow.com/questions/20897020/... stackoverflow.com/questions/3131136/integers-caching-in-java etc expliquer en détail la question que vous avez mentionné; il est préférable de lire les docs (ou lib source) que de créer des pseudo-tests avec le risque de la localité des résultats - non seulement vous avez complètement oublié la limite inférieure de la cache (c'est à dire -128 par défaut), non seulement vous avez tout-en-un (le max est de 127, 128 pas),
- mais vous avez complètement aucune garantie pour recevoir le même résultat sur n'importe quelle machine - puisque vous pouvez facilement augmentation la taille du cache de vous-même, YMMV. Également, OP question était comment bien comparer deux nombres Entiers - vous n'ai pas répondu à tous.
- Je respecte votre opinion et la perception ici. Je pense que nous avons juste fondamentalement différentes approches de la CS.
- ce n'est pas à propos de avis, ni perception - c'est sur le faits, qui vous sincerelly manqué. Faire un pseudo-test prouvant rien, sans aucune sauvegarde des données (documents, source etc.) et, sans répondre à l'OP questions ne mérite pas d'être appelé ni bonne Q&A, ni la CS. Comme pour "approche différente" - CS est, par définition, un science; ce que vous avez fait la science n'est pas, c'est un trompeuse trivia (ou une intrigante commentaire, si indiqué correctement) - si vous souhaitez qu'il soit science, corriger les défauts fondamentaux dans votre réponse ou démystifier leur judicieusement, que c'est comme d'examen par les pairs fonctionne.
- Assurez-vous alors, je vais essayer de remédier aux défauts. Je n'ai pas oublié à propos de la limite inférieure, je n'ai pas l'impression que c'était intéressant et a choisi de ne pas l'inclure. Je ne crois pas que j'ai un hors d'une erreur, j'ai indiqué le chemin que java (que j'ai précisé sur ma machine, dans ma situation) arrêté l'optimisation de cet été, qui est à la 128. Si je l'avais indiqué, la valeur max c'est pour, que vous avez raison, la réponse aurait été de 127.
- Pour répondre à votre question, je m'approche de l'apprentissage de la programmation et de l'enseignement, non pas par la lecture de docs, mais en poussant sur le monde (les outils, les langages, frameworks, etc) autour de nous et en observant les résultats. Cependant, vous faites un bon point que c'est vraiment plus d'un commentaire. Étant donné que n'ont pas une façon pour moi de rendre cela plus exploratoire commentaire y compris le code, je vais laisser ça comme une réponse pour l'instant. Si vous votez pour fermer, je ne serais pas offensé et laisse les votes/système de le gérer.
- lors de la rédaction d'une réponse à la question Q/A format de votre réponse il ne faut pas environ ce que vous vous sentez personnellement intéressant, mais sur le ce que OP (et donc, la question elle-même) besoins/exige et/ou ce un hasard visiteur que les Q/A envisager soit une très utile, claire et vérifiable, de l'information au sujet de la question - encore une fois, votre code est trompeur pour les futurs visiteurs (pour les raisons évoquées dans mon premier commentaire), et l'approche de vous présenter peut être une source de beaucoup de mauvaises habitudes de programmation. pourquoi -
- (et concernant les "méthodes d'apprentissage"), porte sur le fait que "stimuler le monde" a un sens seulement quand c'est fait systématiquement, qui, en fait, prouve quelque chose. Bons repères de travail, c'est comment l'ingénierie inverse fonctionne, c'est le fonctionnement de la science. Vous n'avez pas fait (remarque c'est déjà fait dans le Q/Comme je l'ai relié au début), puisque vous a présenté les données (code & sortie) sans un support de données (docs), b) étendue de la couverture de test. Honnêtement, je préfère amélioration du repérage & enlever; aussi, il n'y a pas de "fermer" pour avoir des réponses, c'est pour des questions autant que je sache.
InformationsquelleAutor Cory Kendall
8

Appel
```
if (a == b)
```
Fonctionne la plupart du temps, mais il n'est pas garanti pour toujours, donc ne l'utilisez pas.

La plus appropriée pour comparer deux Entiers des classes pour l'égalité, en supposant qu'ils sont appelés 'a' et 'b' est l'appel de:
```
if(a != null && a.equals(b)) {
  System.out.println("They are equal");
}
```
Vous pouvez également utiliser ce moyen qui est légèrement plus rapide.
```
   if(a != null && b != null && (a.intValue() == b.intValue())) {
      System.out.println("They are equal");
    } 
```
Sur ma machine 99 milliards d'opérations ont eu 47 secondes à l'aide de la première méthode, et 46 secondes à l'aide de la seconde méthode. Vous devez être en le comparant des milliards de valeurs de voir la différence.

Note que " a " peut être nulle puisque c'est un Objet. La comparaison de cette façon à ne pas provoquer une exception de pointeur null.

Pour comparer des plus et des moins, utiliser
```
if (a != null && b!=null) {
    int compareValue = a.compareTo(b);
    if (compareValue > 0) {
        System.out.println("a is greater than b");
    } else if (compareValue < 0) {
        System.out.println("b is greater than a");
    } else {
            System.out.println("a and b are equal");
    }
} else {
    System.out.println("a or b is null, cannot compare");
}
```
- if (a==b) ne fonctionne que pour les petites valeurs et ne fonctionne pas la plupart du temps.
- Il fonctionne jusqu'à 127 que c'est Java par défaut de l'Entier de cache, ce qui permet de s'assurer que tous les nombres jusqu'à 127 ont la même valeur de référence. Vous pouvez définir le cache supérieur à 127 si vous le souhaitez, mais il suffit de ne pas utiliser == pour être sûr.
InformationsquelleAutor otterslide
7

tl;dr mon avis est d'utiliser un unaire + pour déclencher l'unboxing sur l'un des opérandes lors de la vérification de la valeur de l'égalité, et il suffit d'utiliser les opérateurs mathématiques autrement. Justification suit:

Il a été déjà mentionné que == comparaison pour Integer est l'identité de la comparaison, qui n'est généralement pas ce qu'est un programmeur voulez, et que le but est de faire la comparaison de la valeur; encore, j'ai fait un peu de science sur la façon de faire la comparaison la plus efficace, à la fois en terme de code de la compacité, de la justesse et de la vitesse.

J'ai utilisé l'habitude tas de méthodes:
```
public boolean method1() {
    Integer i1 = 7, i2 = 5;
    return i1.equals( i2 );
}

public boolean method2() {
    Integer i1 = 7, i2 = 5;
    return i1.intValue() == i2.intValue();
}

public boolean method3() {
    Integer i1 = 7, i2 = 5;
    return i1.intValue() == i2;
}

public boolean method4() {
    Integer i1 = 7, i2 = 5;
    return i1 == +i2;
}

public boolean method5() { //obviously not what we want..
    Integer i1 = 7, i2 = 5;
    return i1 == i2;
}
```
et a obtenu ce code après la compilation et la décompilation:
```
public boolean method1() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
return var1.equals( var2 );
}
public boolean method2() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2.intValue() == var1.intValue() ) {
return true;
} else {
return false;
}
}
public boolean method3() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2.intValue() == var1.intValue() ) {
return true;
} else {
return false;
}
}
public boolean method4() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2.intValue() == var1.intValue() ) {
return true;
} else {
return false;
}
}
public boolean method5() {
Integer var1 = Integer.valueOf( 7 );
Integer var2 = Integer.valueOf( 5 );
if ( var2 == var1 ) {
return true;
} else {
return false;
}
}
```
Comme vous pouvez le voir facilement, la méthode 1 appels Integer.equals() (évidemment), les méthodes 2-4 résultat dans exactement le même code, en dépliant les valeurs par le biais de .intValue() et ensuite de les comparer directement, et la méthode 5 juste déclenche une identité de comparaison, à cause d'une mauvaise façon de comparer les valeurs.

Depuis (comme déjà mentionné, par exemple en JS) equals() occasionne des frais généraux (qu'il a à faire instanceof et incontrôlées cast), les méthodes 2-4 travaillera avec exactement la même vitesse, noticingly mieux que la méthode 1 lorsque utilisé dans les boucles serrées, depuis HotSpot n'est pas susceptible d'optimiser les jette & instanceof.

C'est assez similaire avec d'autres opérateurs de comparaison (par exemple,</>) - ils vont déclencher des unboxing, tout en utilisant compareTo() ne veut pas le faire, mais cette fois, l'opération est très optimisable par HS depuis intValue() est juste une méthode de lecture (le premier candidat à être optimisé out).

À mon avis, le rarement utilisé la version 4 est la plus concise - tout assaisonné C/développeur Java sait que unaire plus est, dans la plupart des cas égale à jeter à int/.intValue() - si c'est peut-être un peu WTF moment pour certains (surtout ceux qui n'ont pas utilisé unaire plus au cours de leur vie), il montre sans doute le but le plus clairement et le plus sèchement - il montre que nous voulons un int valeur de l'un des opérandes, forçant les autres de la valeur à unbox ainsi. C'est aussi, incontestablement, le plus semblable à la régulière i1 == i2 comparaison utilisée pour des primitifs int valeurs.

Mon vote va pour i1 == +i2 & i1 > i2 style pour Integer objets, à la fois pour la performance & des raisons de cohérence. Il fait également le code portable de primitives sans rien changer d'autre que la déclaration de type. À l'aide de méthodes appelées semble que l'introduction de la sémantique de bruit pour moi, semblable à la très critiquée bigInt.add(10).multiply(-3) style.
- Pouvez-vous expliquer ce qu'est le + signifie dans la méthode 4? J'ai essayé de chercher sur google mais je n'ai eu normale usages de ce symbole (ajout, la concaténation).
- il signifie exactement ce que j'ai écrit - unary + (unaire plus), voir par exemple stackoverflow.com/questions/2624410/...
InformationsquelleAutor vaxquis

Dans mon cas, je devais comparer les deux Integers pour l'égalité, où les deux d'entre eux pourraient être null. Recherché sujet similaire, n'a pas trouvé quelque chose élégante pour cette. Est venu avec un simple utilitaire de fonctions.

public static boolean integersEqual(Integer i1, Integer i2) {
if (i1 == null && i2 == null) {
return true;
}
if (i1 == null && i2 != null) {
return false;
}
if (i1 != null && i2 == null) {
return false;
}
return i1.intValue() == i2.intValue();
}
//considering null is less than not-null
public static int integersCompare(Integer i1, Integer i2) {
if (i1 == null && i2 == null) {
return 0;
}
if (i1 == null && i2 != null) {
return -1;
}
return i1.compareTo(i2);
}

InformationsquelleAutor JackHammer

-1

cette méthode permet de comparer deux Entiers avec null vérifier, voir les tests

public static boolean compare(Integer int1, Integer int2) {
if(int1!=null) {
return int1.equals(int2);
} else {
return int2==null;
}
//inline version:
//return (int1!=null) ? int1.equals(int2) : int2==null;
}
//results:
System.out.println(compare(1,1));           //true
System.out.println(compare(0,1));           //false
System.out.println(compare(1,0));           //false
System.out.println(compare(null,0));        //false
System.out.println(compare(0,null));        //false
System.out.println(compare(null,null));     //true

ajouter quelques explications pour votre réponse..
Pour cela, je pense qu'il pourrait être préférable d'utiliser Objects.equals(x,y) méthode au lieu de rouler votre propre.

InformationsquelleAutor Alex Torson

Vous devez vous connecter pour publier un commentaire.