¿Por qué es de 128 128 == == falsa, pero 127 127 es cierto cuando se comparan envolturas enteros en Java?

Question

class D {
    public static void main(String args[]) {
        Integer b2=128;
        Integer b3=128;
        System.out.println(b2==b3);
    }
}

Salida:

false

---

class D {
    public static void main(String args[]) {
        Integer b2=127;
        Integer b3=127;
        System.out.println(b2==b3);
    }
}

Salida:

true

Nota: Los números entre -128 y 127 son verdaderas

.

Answer 1

Cuando se compila un número literal en Java y la asigna a un entero (I capital), el compilador emite:

Integer b2 =Integer.valueOf(127)

Esta línea de código también se genera cuando se utiliza autoboxing.

valueOf se implementa de tal manera que ciertos números se "combinaron", y se devuelve la misma instancia para valores menores que 128.

A partir del código fuente de Java 1.6, la línea 621:

public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

El valor de high se puede configurar para otro valor, con la propiedad del sistema.

  

-Djava.lang.Integer.IntegerCache.high = 999

Si ejecuta su programa con que la propiedad del sistema, que es la salida real!

La conclusión obvia: no depender de dos referencias son idénticos, siempre compararlos con el método .equals()

.

Así b2.equals(b3) imprimirá cierto para todos los valores lógicamente iguales de b2, b3.

Tenga en cuenta que la memoria caché Integer no está allí por razones de rendimiento, sino más bien para adaptarse a la JLS, sección 5.1.7 ; la identidad del objeto se debe dar para los valores de -128 a 127 inclusive.

Entero # valueOf (int) también documenta este comportamiento:

  

es probable que el rendimiento significativamente mejor rendimiento espacio y el tiempo por el almacenamiento en caché valores solicitados con frecuencia este método. Este método siempre almacenará en caché valores encuentra entre -128 y 127, inclusive, y puede almacenar en caché otros valores fuera de este intervalo.

Answer 2

Autoboxing almacena en caché -128 a 127. Esto se especifica en el JLS ( 5.1.7 ).

  

Si el valor p está en caja es verdadero, falso, un byte, un char en el rango \ u0000 a \ u007f, o un int o número corto entre -128 y   127, a continuación, vamos a R1 y R2 sean los resultados de las dos conversiones de boxeo   de p. Siempre es el caso de que r1 r2 ==.

Una simple regla para recordar cuando se trata de objetos es - el uso .equals si desea comprobar si los dos objetos son "iguales", el uso == cuando se quiere ver si apuntan a la misma instancia

.

Answer 3

El uso de tipos de datos primitivos, enteros, produciría cierto en ambos casos, el resultado esperado.

Sin embargo, ya que usted está usando objetos Entero el operador == tiene un significado diferente.

En el contexto de objetos, == comprueba para ver si las variables se refieren a la misma referencia de objeto.

Para comparar el valor de los objetos que deben utilizar el método equals () Por ejemplo.

 b2.equals(b1)

que indicará si b2 es menor que b1, mayor que, o igual a (comprobar la API para los detalles)

Answer 4

Es la optimización de memoria en Java relacionados.

  

para guardar en la memoria, todos los objetos de envoltura '' vuelve a utilizar Java cuyos valores   caer en las siguientes gamas:

     

Todos los valores booleanos (verdadero y falso)

     

Todos Los valores de byte

     

Todos los valores de caracteres de \ u0000 a \ u007f (es decir 0 a 127 en decimal)

     

Todos los valores cortas y número entero de -128 a 127.

Answer 5

Tener un vistazo a la Integer.java, si el valor se encuentra entre -128 y 127, que utilizará la piscina en caché, por lo (Integer) 1 == (Integer) 1 mientras (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);
}       

Answer 6

escribí lo siguiente ya que este problema no es sólo específica a entero. Mi conclusión es que la mayoría de las veces si se utiliza la API de forma incorrecta, alféizar ve un comportamiento incorrecto. Utilizarlo correctamente y debería ver el comportamiento correcto:

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

}