Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti