¿Cuál es la causa de este extraño comportamiento de Java?

Question

quería probar el operador '==' s en Long y esto es lo que he encontrado: el siguiente código:

public static void main(final String[] args) { 
    final Long n = 0L; 
    final Long m = 0L; 
    System.out.println(n + " == " + m + " : " + (n == m)); 

    final Long a = 127L; 
    final Long b = 127L; 
    System.out.println(a + " == " + b + " : " + (a == b)); 

    final Long A = 128L; 
    final Long B = 128L; 
    System.out.println(A + " == " + B + " : " + (A == B)); 

    final Long x = -128L; 
    final Long y = -128L; 
    System.out.println(x + " == " + y + " : " + (x == y)); 

    final Long X = -129L; 
    final Long Y = -129L; 
    System.out.println(X + " == " + Y + " : " + (X == Y)); 
} 

salidas:

0 == 0 : true 
127 == 127 : true 
128 == 128 : false 
-128 == -128 : true 
-129 == -129 : false 

La única explicación que podría venir fue que la JVM almacena todos los valores long dentro de [-128, 127] en el espacio Perm, y da su dirección a Long sy a todo lo que está fuera del rango anterior crea una nueva asignación para cada valor estático encontrado en el código.

¿Estoy cerca de estar en lo cierto? ¿En qué situaciones debemos estar conscientes de comportamientos similares?

PS. Sé que debería usar un cheque null y luego .equals() para comparar objetos, pero tenía curiosidad si alguien sabía la respuesta.

EDITAR

Después jtahlborn 's respuesta que me dio la palabra clave de auto-boxing He encontrado este artículo con el well-documented answer

Answer 1

Este es el resultado de la auto-boxing . Ver Long.valueOf().

Answer 2

-128 to +127 se evaluará a verdadero usando el operador == si es comparing object references. Los valores Long (de -128 a +127) se ponen en un caché y se devuelven varias veces, mientras que los números más altos y más bajos generan new Long cada vez.

Esto es aplicable a las clases primitivas de contenedor Integer, Float también. Pruébalo para Integer y Float.

Answer 3

Long tiene una caché interna para valores de -128 a 127. Si se crea por LongLong.valueOf(long) método o autoboxing en este intervalo siempre recibe el mismo objeto para iguales valores. Es por eso que '==' funciona para 0, 127 y -128 en tu ejemplo.

Si crea Long fuera [-128, 127], entonces siempre se creará una nueva instancia si el objeto Long. Es por eso que '==' no funciona para 128 y -129.

Echa un vistazo a Long.valueOf(long) código fuente.