Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Comparación de objetos Integer: valores, referencias y null

Distingue la identidad de los objetos de la igualdad de sus valores. Aprende cuándo `==` convierte un `Integer` en `int` y cómo comparar referencias que pueden ser `null`.

Versión: Java SE 21

Sintaxis

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.

Si ambos operandos son de tipo Integer, == compara las referencias. Devuelve true si apuntan al mismo objeto o si ambas son null. Dos objetos distintos pueden contener el mismo int. Integer.valueOf(int) guarda en caché los valores de −128 a 127, ambos incluidos, y puede guardar también otros valores. No uses == para comparar los valores de dos objetos Integer.

El método de instancia Integer.equals(Object) solo devuelve true si el argumento es un Integer que contiene el mismo int. Devuelve false si el argumento es null o es un Long con el mismo valor numérico. Invocar el método sobre una referencia null lanza NullPointerException.

Integer.intValue() devuelve el valor primitivo int. Cuando == compara un Integer con un int, Java desempaqueta automáticamente el Integer y compara los valores numéricos. Tanto invocar intValue() sobre una referencia null como desempaquetar null automáticamente lanza NullPointerException.

El método estático java.util.Objects.equals(Object, Object) devuelve true para dos argumentos null. Si los dos argumentos son de tipo Integer, devuelve false cuando solo uno es null; si ninguno es null, aplica la regla de igualdad de valores de Integer. Usa este método si cualquiera de las referencias puede ser null.

Ejemplos

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

Resultado

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

Las dos llamadas a `new Integer(42)` crean deliberadamente objetos distintos con el mismo valor, con independencia de la caché. El constructor está obsoleto y marcado para su eliminación; solo se usa para esta demostración. En el código habitual, usa el empaquetado automático o `Integer.valueOf(int)`. El bloque `catch` final muestra qué ocurre al desempaquetar `null`.

Lecciones relacionadas

  • Java · Lección 48 · Avanzado · Versión: 2

Fuentes