Dlaczego 128 = = 128 jest fałszywe, ale 127= = 127 jest prawdziwe podczas porównywania wrapperów całkowitych w Javie?

Autoboxing Cache -128 do 127. Jest to określone w JLS (5.1.7).

Jeśli wartość p jest ustawiona w polu true, false, bajt, znak w zakresie od \u0000 do \u007f, lub liczba int lub krótka pomiędzy -128 i 127, niech r1 i r2 będą wynikami dowolnych dwóch przeliczników boksu P. zawsze jest tak, że r1 == r2.

Prostą regułą do zapamiętania przy obsłudze obiektów jest-use .równa się, jeśli chcesz sprawdzić, czy dwa obiekty są "równe", użyj==, gdy chcesz sprawdzić, czy wskazują na tę samą instancję.

Użycie prymitywnych typów danych, ints, wytworzyłoby true w obu przypadkach oczekiwane wyjście.

Jednakże, ponieważ używasz obiektów całkowitych, operator = = ma inne znaczenie.

W kontekście obiektów = = sprawdza, czy zmienne odnoszą się do tego samego obiektu.

Aby porównać wartość obiektów należy użyć metody equals() Np.

 b2.equals(b1)

Który wskaże, czy b2 jest mniejszy niż b1, większy lub równy (sprawdź API dla szczegóły)

Jest to optymalizacja pamięci w Javie.

Aby zapisać w pamięci, Java "wykorzystuje" wszystkie obiekty wrappera, których wartości spadek w następujących zakresach:

Wszystkie wartości logiczne (true I false)

Wszystkie wartości bajtów

Wszystkie wartości znaków od \u0000 do \u007f (tj. od 0 do 127 w układzie dziesiętnym)

Wszystkie krótkie i całkowite wartości od -128 do 127.

Uwaga:

• Jeśli utworzysz Boolean z new Boolean (value); zawsze otrzymasz nowy obiekt

• Jeśli utworzysz łańcuch z nowym łańcuchem (wartością); zawsze otrzymasz nowy obiekt

• Jeśli utworzysz liczbę całkowitą z nową liczbą całkowitą (wartość); zawsze otrzymasz nowy obiekt

Itd.

Spójrz na liczbę całkowitą.java, jeśli wartość mieści się w przedziale od -128 do 127, użyje buforowanej puli, więc (Integer) 1 == (Integer) 1 while (Integer) 222 != (Integer) 222

 /**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}       

Napisałem co następuje, ponieważ ten problem nie jest tylko specyficzny dla Integer. Mój wniosek jest taki, że częściej, jeśli używasz API nieprawidłowo, widzisz nieprawidłowe zachowanie. Użyj go poprawnie i powinieneś zobaczyć prawidłowe zachowanie:

public static void main (String[] args) {
    Byte b1=127;
    Byte b2=127;

    Short s1=127; //incorrect should use Byte
    Short s2=127; //incorrect should use Byte
    Short s3=128;
    Short s4=128;

    Integer i1=127; //incorrect should use Byte
    Integer i2=127; //incorrect should use Byte
    Integer i3=128;
    Integer i4=128;

    Integer i5=32767; //incorrect should use Short
    Integer i6=32767; //incorrect should use Short

    Long l1=127L;           //incorrect should use Byte
    Long l2=127L;           //incorrect should use Byte
    Long l3=13267L;         //incorrect should use Short
    Long l4=32767L;         //incorrect should use Short
    Long l5=2147483647L;    //incorrect should use Integer 
    Long l6=2147483647L;    //incorrect should use Integer
    Long l7=2147483648L;
    Long l8=2147483648L;

    System.out.print(b1==b2); //true  (incorrect) Used API correctly
    System.out.print(s1==s2); //true  (incorrect) Used API incorrectly
    System.out.print(i1==i2); //true  (incorrect) Used API incorrectly
    System.out.print(l1==l2); //true  (incorrect) Used API incorrectly

    System.out.print(s3==s4); //false (correct) Used API correctly
    System.out.print(i3==i4); //false (correct) Used API correctly
    System.out.print(i5==i6); //false (correct) Used API correctly
    System.out.print(l3==l4); //false (correct) Used API correctly
    System.out.print(l7==l8); //false (correct) Used API correctly
    System.out.print(l5==l6); //false (correct) Used API incorrectly

}