Inkrementieren und Dekrementieren Objektwert ändern

Question

Kann mir jemand den Grund für die Änderung der Ausgabe sagen.

public class Demo { 
    public void demo() 
    { 
     Integer y = 567; 
     Integer x = y; 
     System.out.println(x + " " + y); 
     System.out.println(y == x); 
     y++; 
     System.out.println(x + " " + y); 
     System.out.println(y == x); 
     y--; 
     System.out.println(x + " " + y); 
     System.out.println(y == x); 
    } 
    public static void main(String args[]) 
    { 
     Demo obj = new Demo(); 
     obj.demo(); 
    } 
} 

OUTPUT:

567 567 

true 

567 568 

false 

567 567 

False 

Hier, warum ich das letzte falsche bekommen.

Answer 1

Integer y = 567; // y=567 
    Integer x = y; // x is equal to y object 
    System.out.println(x + " " + y); // out put x and y so obviously x and y are 567 
    System.out.println(y == x); // here x and y are in same reference. so this x==y is true and out put is true. 
    y++; // increment y by 1. then y=568 
    System.out.println(x + " " + y); // now x= 567 and y= 568 
    System.out.println(y == x);// now x not equals to y then false will print 
    y--; // again decrement y value 
    System.out.println(x + " " + y); // again x and y are same 567 
    System.out.println(y == x);// here y.value == x.value but x and y object wise not equal since object x and y are referring deference points 

Answer 2

Weil x und y sich auf 2 verschiedene Objekte beziehen.

Der erste entblockt y, um int zu dekrementieren, und dekrementiert ihn dann zu Integer. Und diese neue Box-Integer bezieht sich auf einen anderen Speicherort.

Im Idealfall ist es bei Wrapper-Klassen besser, die equals-Methode für das Wrapper-Objekt als den Operator == aufzurufen.

Answer 3

y == x prüft auf Inhaltsgleichheit, das heißt, ob sie auf dasselbe Objekt zeigen, nicht ob das Objekt, auf das sie gezeigt haben, dasselbe enthält int. Besonders wenn x, y >= 128.

Verwenden

y.equals(x); 

oder

(int) y == (int) x 

oder x und y als int stattdessen erklären.

Beachten Sie, dass das automatische Unboxing nicht in Integer == Integer oder Integer != Integer erfolgt.

Answer 4

Ihre

Integer y = 567; 
    Integer x = y; 

zu

int y = 567; 
    int x = y; 

ändern und das suprprising Verhalten verschwunden sein. Meine Vermutung ist, dass Sie über Javas implizite Autoboxing der primitiven Werte in Wrapper-Objekte gestolpert sind, und glauben, dass Sie die Zahlen direkt manipulieren.

Answer 5

Wenn Sie primitive int anstelle der Integer verwenden. Die endgültige Ausgabe wäre true. Wenn Sie jedoch die Klasse Integer verwenden, sind dies Object s. Wenn Sie die equals Methode verwenden, wäre die endgültige Ausgabe true.

Answer 6

Sie verwenden Integer, das ein unveränderliches Objekt ist.

Grundsätzlich ist Ihr Code

y = new Integer(y.intValue() + 1); 

und

y = new Integer(y.intValue() - 1); 

Deshalb sind Sie zwei neue Integer Erstellen von Objekten, die nicht gleich sind (==) wie die vorherigen Objekte.

Dieses Verhalten wird Autoboxing in Java aufgerufen. Diese

Answer 7

ist, da der Compiler tut dies intern:

y-- 

bedeutet:

int _y = y.intValue(); 
_y--; 
y = Integer.valueOf(_y); 

Daher y hat eine neue Integer Instanz. Sie führen Objektreferenzüberprüfung (bei Verwendung von ==) durch und prüfen die Gleichheitsprüfung nicht.

Verwenden Sie equals() Methode, um 2 Werte auszuwerten.

Answer 8

Selbst, wenn Sie

Integer a = new Integer(1000); 
Integer b = new Integer(1000); 

a == b erstellen - falsche

aber für

Integer a = new Integer(1); 
Integer b = new Integer(1); 

a == b - gilt

In Java gibt es ein Cache mit kleinen Ganzzahlen: -127 bis 128. Alle anderen Ganzzahlen sind neu erstellte Objekte und sie können nicht gleich sein.