Compruebe si Int es nulo en Java

Este artículo explora cómo comprobar valores nulos con el tipo int de Java, mediante la clase envolvente Integer. También trata las mejores prácticas que mantienen el código fiable y robusto cuando intervienen enteros anulables.

¿Puede int ser nulo en Java?

Primero debe quedar clara una cosa: int es un tipo de dato primitivo. Los tipos primitivos contienen su valor directamente, por lo que un int nunca puede ser null: siempre contiene algún número, 0 por defecto. La ausencia de un valor solo puede representarse con la clase envolvente Integer, cuyos objetos sí pueden ser null.

Por eso es importante la comprobación. Antes de usar un Integer como int — por ejemplo, cuando se desempaqueta para un cálculo o se pasa donde se espera un int — debe comprobarse: usar un Integer null como int lanza una NullPointerException. Si necesita la forma envolvente de un valor primitivo, vea cómo convertir int a Integer.

Comprobar si un Integer es nulo

La comprobación en sí es una simple comparación con null. El siguiente ejemplo completo muestra un int primitivo, un Integer anulable y la comprobación en acción:

public class CheckIfIntIsNullExample {
  public static void main(String[] args) {
    // Part 1: Primitive int
    int primitiveInt = 0;
    System.out.println("Primitive int value: " + primitiveInt);

    // Part 2: Nullable Integer
    Integer nullableInt = null;
    System.out.println("Nullable Integer value: " + nullableInt);

    // Part 3: Checking for null
    if (nullableInt != null) {
      int intValue = nullableInt.intValue();
      System.out.println("Value is: " + intValue);
    } else {
      System.out.println("Value is null");
    }
  }
}

Salida:

Primitive int value: 0
Nullable Integer value: null
Value is null

En la primera parte del código, primitiveInt se inicializa con el valor 0, lo que demuestra el uso estándar de un entero primitivo: siempre contiene un valor. En la segunda parte, nullableInt se declara como un objeto Integer y se establece en null, algo que solo permite la clase envolvente. En la tercera parte, una sentencia if compara nullableInt con null: si no es null, el valor int se extrae con intValue() y se imprime; en caso contrario, el programa imprime que el valor es nulo.

Mejores prácticas para manejar enteros anulables

Comprobación de nulos consistente

Compruebe si un objeto Integer es null antes de realizar operaciones con él o extraer su valor int subyacente, y hágalo de forma consistente. Esta práctica minimiza el riesgo de encontrar NullPointerExceptions y mejora la estabilidad general del código.

Documentación clara

Documente dónde se esperan enteros anulables, cómo deben manejarse y qué significa un valor null. Una documentación clara evita usos indebidos involuntarios y ayuda a otros desarrolladores a comprender el comportamiento del código.

Valores predeterminados e inicialización

Cuando sea apropiado, proporcione un valor predeterminado para un entero anulable — por ejemplo, sustituyendo un valor de reserva cuando el valor está ausente — para que las operaciones que dependen de él no fallen inesperadamente. Unos valores predeterminados sensatos hacen que el comportamiento del código sea más predecible.

Uso de Optional (Java 8 y posterior)

En Java 8 y versiones posteriores, la clase Optional puede expresar la posible ausencia de un valor en el propio tipo. Optional<Integer> ofrece métodos para manejar explícitamente los casos de valor presente y ausente, proporcionando una forma más clara y concisa de expresar la intención en el código.

Manejo de excepciones

Cuando la ausencia de un valor se considera excepcional, manéjela deliberadamente — falle pronto con un error claro o recupérese explícitamente — en lugar de dejar que una NullPointerException aparezca lejos de su causa. Un manejo de excepciones robusto evita la terminación inesperada del programa.

Conclusión

Un int nunca puede ser null; solo su clase envolvente Integer puede serlo. La comprobación es una simple comparación con null, y aplicarla de forma consistente — junto con una documentación clara, valores predeterminados sensatos y Optional donde encaje — evita las NullPointerException y mantiene el código Java fiable y robusto.