Come funzionano gli operatori! = E == su Integers in Java?

Il seguente codice mi è sembrato molto confuso poiché ha fornito due output diversi. Il codice è stato testato su jdk 1.7.

public class NotEq { public static void main(String[] args) { ver1(); System.out.println(); ver2(); } public static void ver1() { Integer a = 128; Integer b = 128; if (a == b) { System.out.println("Equal Object"); } if (a != b) { System.out.println("Different objects"); } if (a.equals(b)) { System.out.println("Meaningfully equal."); } } public static void ver2() { Integer i1 = 127; Integer i2 = 127; if (i1 == i2) { System.out.println("Equal Object"); } if (i1 != i2){ System.out.println("Different objects"); } if (i1.equals(i2)){ System.out.println("Meaningfully equal"); } } } 

Produzione:

[uscita ver1]
Oggetti diversi
Significativamente uguale.

[uscita ver2]
Oggetto uguale
Significativamente uguale

Perché il test == e! = Produce risultati diversi per ver1 () e ver2 () per lo stesso numero molto meno dell’Integer.MAX_VALUE? Si può concludere che il controllo == di numeri superiori a 127 (per classi wrapper come Integer come mostrato nel codice) è totalmente inutile?

Gli integer sono memorizzati nella cache per valori compresi tra -128 e 127, quindi Integer i = 127 restituirà sempre lo stesso riferimento. Integer j = 128 non lo farà necessariamente. Sarà quindi necessario utilizzare equals per testare l’uguaglianza dell’int sottostante.

Questo fa parte della specifica del linguaggio Java :

Se il valore p in box è true, false, un byte o un char nell’intervallo da \ u0000 a \ u007f o un numero int o short compreso tra -128 e 127 (inclusi), quindi r1 e r2 devono essere i risultati di ogni due conversioni di boxe di p. È sempre il caso che r1 == r2.

Ma 2 chiamate a Integer j = 128 potrebbero restituire lo stesso riferimento (non garantito):

Ad esempio, meno implementazioni a memoria limitata potrebbero memorizzare nella cache tutti i valori char e short, nonché i valori int e long nell’intervallo da -32K a +32K.

Perché i piccoli interi sono internati in Java e hai provato i numeri su lati diversi del limite di “piccolezza”.

Esiste una cache di oggetti Integer da -128 e fino a 127 per impostazione predefinita. Il bordo superiore può essere configurato. Il bordo superiore della cache può essere controllato dall’opzione VM -XX:AutoBoxCacheMax=

Stai usando questa cache quando usi il modulo:

  Integer i1 = 127; 

o

 Integer i1 = Integer.valueOf(127); 

Ma quando lo usi

 Integer i1 = new Integer(127); 

allora sei garantito per ottenere un nuovo object non collegato. In quest’ultimo caso entrambe le versioni mostrano gli stessi risultati. Usando le versioni memorizzate nella cache possono essere diverse.

https://www.owasp.org/index.php/Java_gotchas

Ho ricevuto questo link da uno dei miei professori, piuttosto informativo.

Java memorizza in cache gli interi da -128 a 127 Ecco perché gli oggetti SONO uguali.

Penso che gli operatori == e! = Quando si hanno a che fare con le primitive funzioneranno come si stanno attualmente usando, ma con gli oggetti (intero e int) si vorrà eseguire test con il metodo .equals ().

Non sono sicuro su questo, ma con gli oggetti il ​​== testerà se un object è lo stesso object o no, mentre .equals () eseguirà il test che quei due oggetti contengano l’equivalenza in valore (o il metodo dovrà essere creato / sostituito) per oggetti personalizzati.