CKTIS / Java
Confrontare oggetti Integer: valori, riferimenti e null
Distingui l’identità degli oggetti dall’uguaglianza dei valori. Scopri quando `==` converte un `Integer` in `int` e come confrontare riferimenti che possono essere `null`.
Versione: Java SE 21
Sintassi
Instance methods on java.lang.Integer: boolean equals(Object obj); int intValue(). Static method on java.util.Objects: static boolean equals(Object a, Object b). With Integer a and b and int n: a == b compares references; a == n unboxes a and compares values.Se entrambi gli operandi sono di tipo Integer, == confronta i riferimenti. Restituisce true se puntano allo stesso oggetto o sono entrambi null. Due oggetti distinti possono contenere lo stesso int. Integer.valueOf(int) usa una cache per i valori da −128 a 127 inclusi e può memorizzarvi anche altri valori. Non usare == per confrontare i valori di due oggetti Integer.
Il metodo di istanza Integer.equals(Object) restituisce true solo se l’argomento è un Integer che contiene lo stesso int. Restituisce false se l’argomento è null o è un Long con lo stesso valore numerico. Invocare il metodo su un riferimento null genera una NullPointerException.
Integer.intValue() restituisce il valore primitivo int. Quando == confronta un Integer con un int, Java esegue automaticamente l’unboxing dell’Integer e confronta i valori numerici. Sia l’invocazione di intValue() su un riferimento null sia l’unboxing automatico di null generano una NullPointerException.
Il metodo statico java.util.Objects.equals(Object, Object) restituisce true se entrambi gli argomenti sono null. Per due argomenti di tipo Integer, restituisce false se solo uno è null; se nessuno è null, applica la regola di uguaglianza dei valori di Integer. Usa questo metodo se uno qualsiasi dei riferimenti può essere null.
Esempi
import java.util.Objects;
public class IntegerComparison {
@SuppressWarnings("removal") // Fresh objects for this demonstration only.
public static void main(String[] args) {
Integer a = new Integer(42);
Integer b = new Integer(42);
Integer missing = null;
System.out.println("same reference: " + (a == b));
System.out.println("Integer.equals: " + a.equals(b));
System.out.println("Integer vs Long: " + a.equals(Long.valueOf(42L)));
System.out.println("intValue comparison: " + (a.intValue() == b.intValue()));
System.out.println("Integer vs int: " + (a == 42));
System.out.println("Objects.equals, same value: " + Objects.equals(a, b));
System.out.println("Objects.equals, one null: " + Objects.equals(a, missing));
System.out.println("Objects.equals, both null: " + Objects.equals(missing, null));
try {
System.out.println(missing == 42);
} catch (NullPointerException e) {
System.out.println("null unboxing: NullPointerException");
}
}
}Risultato
same reference: false Integer.equals: true Integer vs Long: false intValue comparison: true Integer vs int: true Objects.equals, same value: true Objects.equals, one null: false Objects.equals, both null: true null unboxing: NullPointerException
Le due chiamate a `new Integer(42)` creano volutamente oggetti distinti con lo stesso valore, indipendentemente dalla cache. Il costruttore è deprecato e destinato alla rimozione; qui serve solo per la dimostrazione. Nel codice ordinario, usa l’autoboxing o `Integer.valueOf(int)`. Il blocco `catch` finale mostra cosa succede quando si esegue l’unboxing di `null`.
Lezioni correlate
- Java · Lezione 48 · Avanzato · Versione: 2