Cómo comprobar si un array es nulo en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un array en Java es nulo. Comenzaremos entendiendo cómo comprobar si la referencia del array en sí es nula para prevenir NullPointerException.

A continuación, exploraremos cómo combinar las comprobaciones de nulidad con comprobaciones de longitud para un manejo más robusto de los arrays. Finalmente, pondrás a prueba tu comprensión trabajando con un array vacío inicializado.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/DataStructuresGroup -.-> java/arrays("Arrays") subgraph Lab Skills java/if_else -.-> lab-560003{{"Cómo comprobar si un array es nulo en Java"}} java/arrays -.-> lab-560003{{"Cómo comprobar si un array es nulo en Java"}} end

Comprobar si la referencia de un array es nula

En este paso, aprenderemos cómo comprobar si una referencia de array en Java es null. Comprobar la nulidad es una práctica fundamental en la programación Java para prevenir NullPointerException, que son errores de tiempo de ejecución comunes.

Una NullPointerException se produce cuando intentas usar una variable que no se refiere a nada (es null) como si fuera un objeto. Imagina intentar abrir una caja que no existe; eso es similar a lo que sucede cuando obtienes una NullPointerException.

Vamos a crear un sencillo programa Java para demostrar cómo comprobar si una referencia de array es null.

Abre el archivo HelloJava.java en el editor WebIDE si no está abierto.
Reemplaza todo el contenido del archivo con el siguiente código:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Declaring an array reference and setting it to null

        // Check if the array reference is null before trying to use it
        if (names == null) {
            System.out.println("The 'names' array is null.");
        } else {
            System.out.println("The 'names' array is not null.");
        }
    }
}
```
Veamos las nuevas partes de este código:
- String[] names = null;: Esta línea declara una variable de array llamada names que puede contener objetos String. Luego, inmediatamente le asignamos el valor null. Esto significa que la variable names actualmente no se refiere a ningún objeto de array real en la memoria.
- if (names == null): Esta es una instrucción if, que se utiliza para tomar decisiones en la programación. Comprueba si la condición dentro de los paréntesis (names == null) es verdadera. El operador == se utiliza para comparar si la variable names es igual a null.
- System.out.println("The 'names' array is null.");: Esta línea se ejecutará solo si la condición names == null es verdadera.
- System.out.println("The 'names' array is not null.");: Esta línea se ejecutará solo si la condición names == null es falsa (lo que significa que names no es null).
Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado. En la Terminal, ejecuta:
```
javac HelloJava.java
```
Si la compilación es exitosa, no verás ninguna salida.
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
The 'names' array is null.
```
Esta salida confirma que nuestra comprobación identificó correctamente que la referencia del array names es null.

Comprender cómo comprobar la nulidad es crucial para escribir código Java robusto. En el siguiente paso, exploraremos qué sucede cuando intentamos acceder a la longitud de un array que es null y cómo combinar comprobaciones.

Combinar comprobaciones de nulidad y longitud

En el paso anterior, aprendimos cómo comprobar si una referencia de array es null. Ahora, exploremos qué sucede cuando intentamos acceder a la longitud de un array null y cómo combinar la comprobación de nulidad con una comprobación de la longitud del array.

Intentar acceder a la propiedad .length de una referencia de array null resultará en una NullPointerException. Esto se debe a que estás intentando acceder a una propiedad de algo que no existe.

Modifiquemos nuestro programa para demostrar esto y luego agreguemos una comprobación combinada.

Abre el archivo HelloJava.java en el editor WebIDE.
Reemplaza todo el contenido del archivo con el siguiente código:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = null; // Declaring an array reference and setting it to null

        // Attempting to access the length of a null array (will cause an error)
        // int length = names.length; // Uncommenting this line would cause a NullPointerException

        // Combine null check and length check
        if (names != null && names.length > 0) {
            System.out.println("The 'names' array is not null and has elements.");
        } else {
            System.out.println("The 'names' array is null or empty.");
        }
    }
}
```
Esto es lo nuevo o lo que ha cambiado:
- Mantenemos String[] names = null; para comenzar con un array null.
- La línea comentada // int length = names.length; muestra lo que sucedería si intentáramos acceder directamente a la longitud. La hemos comentado para que el programa no se bloquee inmediatamente.
- if (names != null && names.length > 0): Esta es la comprobación combinada.
  - names != null: Esta parte comprueba si la referencia del array names no es null.
  - &&: Este es el operador lógico AND. Ambas condiciones a ambos lados de && deben ser verdaderas para que toda la condición sea verdadera.
  - names.length > 0: Esta parte comprueba si la longitud del array names es mayor que 0. Esta comprobación solo se realiza si la primera parte (names != null) es verdadera, gracias a la naturaleza de cortocircuito del operador && en Java. Esto evita la NullPointerException.
- El bloque else ahora imprime un mensaje que indica que el array es null o está vacío.
Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado:
```
javac HelloJava.java
```
Nuevamente, si tiene éxito, no habrá salida.
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
The 'names' array is null or empty.
```
Esta salida muestra que nuestra comprobación combinada identificó correctamente que el array era null o estaba vacío. Dado que lo inicializamos a null, la primera parte de la condición if (names != null) fue falsa y se ejecutó el bloque else.

Combinar comprobaciones de esta manera es una forma estándar de manejar de forma segura las referencias de array en Java, asegurándote de no encontrar NullPointerException al comprobar propiedades como la longitud o acceder a elementos.

Probar con un array vacío inicializado

En los pasos anteriores, aprendimos sobre cómo comprobar referencias de arrays null y cómo combinarlo con una comprobación de longitud. Vimos que nuestra comprobación combinada identificó correctamente un array null.

Ahora, probemos nuestra comprobación combinada con un array que no es null pero está vacío (tiene una longitud de 0). Este es otro escenario común que encontrarás.

Abre el archivo HelloJava.java en el editor WebIDE.
Modifica la línea donde declaramos e inicializamos el array names. Cambia String[] names = null; a String[] names = new String[0];. El resto del código, incluyendo la instrucción if con la comprobación combinada, debe permanecer igual.

El código actualizado debería verse así:
```
public class HelloJava {
    public static void main(String[] args) {
        String[] names = new String[0]; // Declaring and initializing an empty array

        // Combine null check and length check
        if (names != null && names.length > 0) {
            System.out.println("The 'names' array is not null and has elements.");
        } else {
            System.out.println("The 'names' array is null or empty.");
        }
    }
}
```
Este es el cambio:
- String[] names = new String[0];: Esta línea ahora crea un nuevo array de objetos String con un tamaño de 0. La variable names ahora se refiere a un objeto de array real en la memoria, pero ese array no contiene elementos. No es null.
Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado:
```
javac HelloJava.java
```
Si la compilación es exitosa, no habrá salida.
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
The 'names' array is null or empty.
```
Esta salida es la misma que cuando el array era null. Entendamos por qué. Nuestra condición if es if (names != null && names.length > 0).
- names != null: Esta parte ahora es verdadera porque names se refiere a un objeto de array vacío.
- names.length > 0: Esta parte comprueba si la longitud del array es mayor que 0. Dado que el array tiene una longitud de 0, esta condición es falsa.
- Debido a que la segunda parte de la condición && es falsa, toda la condición (names != null && names.length > 0) se evalúa como falsa y se ejecuta el bloque else.

Esto demuestra que nuestra comprobación combinada identifica correctamente tanto los arrays null como los arrays vacíos, lo cual es a menudo el comportamiento deseado cuando se quiere procesar un array solo si contiene elementos.

Resumen

En este laboratorio (lab), aprendimos cómo comprobar si una referencia de array en Java es null para prevenir NullPointerException. Comenzamos creando un programa simple para demostrar cómo comprobar una referencia de array null utilizando una instrucción if y el operador ==.

Luego exploramos cómo combinar la comprobación de null con una comprobación de longitud para manejar casos en los que el array no es null pero podría estar vacío. Finalmente, probamos nuestra comprobación combinada con un array vacío inicializado para entender la diferencia entre una referencia de array null y un array vacío.