Pourquoi (i <= j && j <= i && i! = J) est-il VRAI?

J'ai écrit un morceau de code Java qui s'exécute dans une boucle infinie.

Voici le code:

public class TestProgram {
    public static void main(String[] args){
        Integer i = new Integer(0);
        Integer j = new Integer(0);

        while(i<=j && j<=i && i!=j){
            System.out.println(i);
        }
    }
}

Dans le code ci-dessus, tout en voyant la condition dans la whileboucle, il semble au début que ce programme n'ira pas à l'intérieur de la whileboucle. Mais en fait, c'est une boucle infinie et continue à imprimer la valeur.

Que se passe-t-il ici?

• i <= jest évaluée à true, parce que unboxing automatique se produit pour des comparaisons int, puis à la fois iet jmaintenir la valeur par défaut, 0.

• j <= iest évalué en trueraison de la raison ci-dessus.

• i != jest évalué à true, car les deux iet jsont des objets différents. Et tout en comparant des objets, il n'est pas nécessaire de déballer automatiquement.

Toutes les conditions sont vraies, et vous ne changez pas iet jen boucle, donc il fonctionne à l'infini.

Parce que vous comparez

• 0 < = 0 (true) // unboxing

• 0 > = 0 (true) // unboxing

• reference != secondReference (true)comme vous créez des objets, pas une comparaison primitive. Donc, il évalue while(true) { // Never ending loop }.

Les objets entiers sont différents. Il est différent du type int de base.

Voir cette réponse: Comment comparer correctement deux nombres entiers en Java?

La i != jpartie est vraie, ce que vous vous attendiez à être faux.

La boucle ne se termine pas car votre condition est vraie (i! = J est vraie car il y a 2 objets différents, utilisez plutôt Integer.valueOf) et à l'intérieur de la boucle les valeurs ne changent pas, donc votre condition reste vraie pour toujours.

Les objets entiers sont différents. Il est différent du type int de base. donc vous pouvez faire comme ça. ce que vous faites, c'est simplement comparer l'objet et bien sûr le résultat est vrai.

Il y a deux cas différents que nous devons d'abord comprendre,

cas 1:

        Integer i = new Integer(10);
        Integer j = new Integer(10);

        System.out.println((i<=j && j<=i && i!=j));
        System.out.println(i!=j);

cas 2:

        Integer i = 10;
        Integer j = 10;

        System.out.println((i<=j && j<=i && i==j));
        System.out.println(i==j);

les deux sont différents, car

dans le cas 1: i!=jsera trueparce que les deux font référence à deux objets différents dans le tas et ne peuvent pas être identiques. Mais

dans le cas 2: i==jsera trueparce que les deux 10 sont des littéraux entiers et Java maintient pool for Integer literalsqui ont une valeur (-128 <= X <= 127). Donc, dans ce cas, 10 <= 127 résultats vrais, donc les deux auront référence au même objet.

La raison en est peut-être que «i» et «j» sont des objets et que la comparaison d'objets n'est pas la même chose que la comparaison de références d'objets. Veuillez envisager d'utiliser! I.equals (j) au lieu de i! = J

Le programme continue d'afficher la même valeur de iparce que vous n'incrémentez ni ne décrémentez la valeur de iou j. La condition dans for continue à être évaluée à true, il s'agit donc d'une boucle infinie.

Entier a = nouvel Entier (0); Entier b = nouvel Entier (0);

Les comparaisons <= et> = utiliseront la valeur sans boîte 0, tandis que le! = Comparera les références et réussira car ce sont des objets différents.

Même cela fonctionnera aussi i, e

Entier a = 1000; Entier b = 1000;

mais cela ne fonctionne pas:

Entier a = 100; Entier b = 100;

La raison en est que Integer utilise en interne la mise en cache pour les objets Integer entre -128 et 127 et renvoie les instances de ce cache pour la plage qu'il couvre. Je ne suis pas sûr mais je suppose que vous pouvez également modifier sa valeur maximale dans le package "java.lang.Integer.IntegerCache.high".

Pour une meilleure compréhension, vérifiez l'URL: https://www.owasp.org/index.php/Java_gotchas#Immutable_Objects_.2F_Wrapper_Class_Caching

vous devez savoir que c'est un peu différent dans && ceci et ceci & quand vous utilisez && alors quand la première condition est vraie alors il vérifie la deuxième condition si c'est faux alors il n'a pas vérifié la troisième condition parce que dans l'opérateur & si une condition est fausse tout le la déclaration est fausse si utiliser || alors s'il voit vrai alors il retourne vrai dans votre code parce que i et j sont égaux, la première et la deuxième condition sont vraies alors dans la troisième condition, elles seront fausses parce qu'elles sont égales et tandis que la condition est fausse.