Perché (i <= j && j <= i && i! = J) restituisce TRUE?

Ho scritto un pezzo di codice Java che viene eseguito in un ciclo infinito.

Di seguito il codice:

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);
        }
    }
}

Nel codice sopra, mentre si vede la condizione nel whileciclo, all'inizio sembra che quel programma non entrerà nel whileciclo. Ma in realtà è un ciclo infinito e continua a stampare il valore.

Cosa sta succedendo qui?

• i <= jviene valutata a true, a causa di auto unboxing accade per i confronti int e poi entrambi ie jtenere premuto il valore di default, 0.

• j <= iviene valutato a truecausa del motivo di cui sopra.

• i != jviene valutato a true, perché entrambi ie jsono oggetti diversi. E durante il confronto degli oggetti, non è necessario unboxing automatico.

Tutte le condizioni sono vere e non stai cambiando ie jin loop, quindi funziona all'infinito.

Perché stai confrontando

• 0 < = 0 (true) // unboxing

• 0 > = 0 (true) // unboxing

• reference != secondReference (true)mentre crei oggetti, non un confronto primitivo. Quindi valuta a while(true) { // Never ending loop }.

Gli oggetti interi sono diversi. È diverso dal tipo int di base.

Vedi questa risposta: come confrontare correttamente due numeri interi in Java?

La i != jparte è vera, che ti aspettavi fosse falsa.

Il ciclo non finisce perché la tua condizione è vera (i! = J è vera perché ci sono 2 oggetti diversi, usa invece Integer.valueOf) e all'interno del ciclo i valori non cambiano, quindi la tua condizione rimane vera per sempre.

Gli oggetti interi sono diversi. È diverso dal tipo int di base. quindi puoi semplicemente fare così. quello che fai è solo confrontare l'oggetto e, naturalmente, il risultato è vero.

Ci sono due diversi casi che dobbiamo prima capire,

caso 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);

caso 2:

        Integer i = 10;
        Integer j = 10;

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

entrambi sono diversi, come

nel caso 1: i!=jsarà trueperché entrambi fanno riferimento a due oggetti diversi nell'heap e non possono essere uguali. Ma

nel caso 2: i==jsarà trueperché entrambi 10 sono letterali interi e Java mantiene pool for Integer literalsche hanno valore (-128 <= X <= 127). Quindi, in questo caso 10 <= 127 risulta vero, quindi entrambi avranno riferimento allo stesso oggetto.

Forse il motivo è che sia "i" che "j" sono oggetti e il confronto degli oggetti non è lo stesso del confronto dei riferimenti agli oggetti. Si prega di considerare l'utilizzo di! I.equals (j) invece di i! = J

Il programma continua a visualizzare lo stesso valore di iperché non stai incrementando o decrementando il valore di io j. La condizione in for continua a essere valutata come vera, quindi è un ciclo infinito.

Intero a = new Integer (0); Intero b = nuovo Intero (0);

I confronti <= e> = useranno il valore unboxed 0, mentre! = Confronterà i riferimenti e avrà esito positivo poiché sono oggetti diversi.

Anche questo funzionerà anche i, e

Intero a = 1000; Intero b = 1000;

ma questo non:

Intero a = 100; Intero b = 100;

Il motivo è perché Integer utilizza internamente la memorizzazione nella cache per oggetti Integer tra -128 e 127 e restituisce istanze da quella cache per l'intervallo che copre. Non ne sono sicuro, ma immagino che tu possa anche modificare il suo valore massimo nel pacchetto "java.lang.Integer.IntegerCache.high".

Per una migliore comprensione, controllare l'URL: https://www.owasp.org/index.php/Java_gotchas#Immutable_Objects_.2F_Wrapper_Class_Caching

devi sapere che è un po 'diverso in && questo e questo e quando usi && allora quando la prima condizione è vera, controlla la seconda condizione se è falsa quindi non controlla la terza condizione perché in & operator se una condizione è falsa tutte le l'istruzione è falsa se si usa || quindi se è vero, restituisce vero nel codice perché i e j sono uguali, la prima e la seconda condizione sono vere, quindi nella terza condizione sarà falso perché sono uguali e mentre la condizione è falsa.