Warum ändert sich das Verhalten des Integer-Konstantenpools bei 127?

Ich bin nicht in der Lage zu verstehen, wie die Java-Konstanten-Pool für Integer arbeitet.

Verstehe ich das Verhalten von Strings ist und daher in der Lage mich zu rechtfertigen, dass es der gleiche Fall mit Integer-Konstanten auch.

So, für Ganzzahlen

Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1==i2); //True

Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1==i2); //False

Bis hier geht alles, in meinem Kopf.

Was ich bin nicht in der Lage zu verdauen ist, es verhält sich anders, wenn ich erhöhen ganze Zahl von 127. Dieses Verhalten ändert sich nach 127, unten ist das code-snippet

Integer i1 = 128;
Integer i2 = 128;
System.out.println(i1==i2); //False. WHY?????

Kann mir jemand helfen zu verstehen?

InformationsquelleAutor der Frage Vivek | 2012-10-27

41

Nein, Konstanten-pool für zahlen nicht die gleiche Weise funktionieren wie bei strings. Für Streicher, nur compile-time-Konstanten sind interniert - in der Erwägung, dass für die wrapper-Typen für integer-Typen, alle Boxen-Betrieb wird immer den pool, wenn es gilt für diesen Wert. So zum Beispiel:
```
int x = 10;
int y = x + 1;
Integer z = y; //Not a compile-time constant!
Integer constant = 11;
System.out.println(z == constant); //true; reference comparison
```
Die Justiz, Freiheit und Sicherheit garantiert, eine kleine Auswahl von gepoolten Werte, aber Implementierungen können mit einer breiteren Palette, wenn Sie wollen.

Beachten, dass, obwohl es ist nicht garantiert, jede Umsetzung habe ich mir angeschaut, verwendet Integer.valueOf durchführen boxing-Operationen - so können Sie erhalten die gleiche Wirkung ohne die Sprache helfen:
```
Integer x = Integer.valueOf(100);
Integer y = Integer.valueOf(100);
System.out.println(x == y); //true
```
Vom Abschnitt 5.1.7 der JLS:

Wenn der Wert p als boxed true, false, ein byte oder ein char im Bereich von \u0000 bis \u007f, oder ein int oder short-Wert zwischen -128 und 127 (einschließlich), dann seien r1 und r2 werden die Ergebnisse von zwei Boxen-Konvertierungen von p. Es ist immer der Fall, dass r1 == r2.

Idealerweise Boxen einen bestimmten Grundwert p, würde immer bedeuten eine identische Referenz. In der Praxis ist dies möglicherweise nicht möglich ist mit den bestehenden Techniken zur Realisierung. Die oben genannten Regeln sind ein pragmatischer Kompromiss. Die Letzte Klausel oben erfordert, dass bestimmte gemeinsame Werte immer boxed in nicht unterscheidbare Objekte. Die Umsetzung kann diesen cache, faul oder eifrig. Für die anderen Werte, diese Formulierung lässt keine Annahmen über die Identität des boxed-Werte auf der programmer ' s Teil. Dies würde es erlauben, (aber nicht erforderlich) Freigabe der einige oder alle diese Verweise.

Dadurch wird sichergestellt, dass in den häufigsten Fällen wird das Verhalten sein, das gewünschte, ohne dass eine unnötige performance-Einbußen, vor allem auf kleinen Geräten. Weniger Speicher-begrenzte Implementierungen, zum Beispiel, cache alle char-und short-Werte, sowie int und long-Werte im Bereich von -32K bis +32K.

InformationsquelleAutor der Antwort Jon Skeet
17

Java verwaltet Ganzzahl-pool von -128 zu 127

Deklarieren Integer wie unten
```
Integer i1 = 127;
```
Ergebnisse in
```
Integer i1 = Integer.valueOf(127);
```
Also, was tatsächlich geschieht, für den ersten Fall ist
```
Integer i1 = 127;<---Integer.valueOf(127);
Integer i2 = 127;<---Integer.valueOf(127);<---Same reference as first
```
Aus dem source-code von Integer für Klasse valueOf Methode
```
public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}
```
So erhalten Sie die gleiche Referenz, wenn der Wert zwischen -128 zu 127 und rufen Sie valueOf es sonst noch so gibt einfach zurück new Integer(i)

Und weil die Referenz ist gleiche Ihre == - operator funktioniert für ganze zahlen zurückgegeben valueOf zwischen diesem Bereich.

InformationsquelleAutor der Antwort Amit Deshpande
7

Java-caches die integer-Objekte im Bereich -128 to 127. Also, wenn Sie versuchen, einen Wert zuweisen, in diesem Bereich zu einer wrapper Objekt, das boxing operation aufrufen Integer.valueOf Methode und wiederum weist einen Verweis auf das Objekt, das sich bereits in den pool.

Auf der anderen Seite, wenn Sie einen Wert zuzuweisen, der außerhalb dieses Bereichs auf ein wrapper Referenz-Typ, Integer.valueOf wird eine neue Integer Objekt für diesen Wert. Und damit, Vergleich der reference für Integer Objekte mit Wert außerhalb dieses Bereichs wird Ihnen false

So,
```
Integer i = 127;  --> //Equivalent to `Integer.valueOf(127)`
Integer i2 = 127;

//Equivalent to `Integer.valueOf(128)`
//returns `new Integer(128)` for value outside the `Range - [-128, 127]`
Integer i3 = 128; 
Integer i4 = 128;

System.out.println(i == i2); //true, reference pointing to same literal
System.out.println(i3 == i4); //false, reference pointing to different objects
```
Aber , wenn Sie Ihre integer-Instanzen mit new - operator wird ein neues Objekt erzeugt, auf Heap.
So,
```
Integer i = new Integer(127);
Integer i2 = new Integer(127);

System.out.println(i == i2); //false
```
InformationsquelleAutor der Antwort Rohit Jain
2

Kurz neueren Versionen der Java-cache Integer im Bereich von -128 bis 127 (256 Werte).
schauen Sie hier

Was genau macht der Vergleich der zahlen mit == machen?

InformationsquelleAutor der Antwort SRJ

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.