Qual è la causa di questo strano comportamento di Java?

Question

Ho voluto mettere alla prova l'operatore '==' su Long s e questo è quello che ho trovato: il seguente codice:

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)); 
} 

uscite:

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

L'unica spiegazione che poteva venire con JVM è stato memorizzato tutti i valori long all'interno di [-128, 127] nello spazio Perm, e dà il loro indirizzo a Long s e per tutto al di fuori dell'intervallo sopra crea una nuova allocazione per ogni valore statico incontrato nel codice.

Sono vicino ad avere ragione? In quali situazioni dobbiamo essere consapevoli di comportamenti simili?

PS. So che dovrei usare un assegno null e poi .equals() per confrontare gli oggetti, ma ero curioso se qualcuno conoscesse la risposta.

EDIT

Dopo jtahlborn 's risposta che mi ha dato la parola auto-boxing ho trovato questo grande articolo con la well-documented answer

Answer 1

questo è il risultato di auto-boxing . Vedi Long.valueOf().

Answer 2

-128 to +127 verrà valutato su true utilizzando l'operatore == se si è comparing object references. I valori Long (da -128 a +127) vengono inseriti in una cache e restituiti più volte, mentre i numeri sempre più alti generano new Long ogni volta.

Questo è applicabile anche alle classi wrapper primitive Integer, Float. Provalo per Integer e Float.

Answer 3

Long ha una cache interna per i valori da -128 a 127. se si crea Long da Long.valueOf(long) metodo o autoboxing in questo intervallo si riceve sempre lo stesso oggetto per valori uguali. Ecco perché '==' funziona con 0, 127 e -128 nel tuo esempio.

Se si crea Long all'esterno [-128, 127], verrà sempre creata una nuova istanza se l'oggetto Long. Ecco perché '==' non funziona per 128 e -129.

Dai un'occhiata al codice sorgente Long.valueOf(long).