Cómo comprobar si un array está vacío en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un array en Java está vacío. Cubriremos la técnica fundamental de comprobar la longitud del array y también abordaremos cómo manejar casos en los que el propio array podría ser nulo. Practicarás estos conceptos con diferentes tipos de arrays para consolidar tu comprensión.

Skills Graph

Comprobar si la longitud del array es cero

En este paso, aprenderemos cómo verificar si un array en Java está vacío comprobando su longitud. Esta es una operación fundamental cuando se trabaja con arrays para evitar errores.

Primero, creemos un nuevo archivo Java llamado ArrayLengthCheck.java en el directorio ~/project. Puedes hacer esto utilizando el Explorador de archivos del WebIDE en el lado izquierdo. Haz clic derecho en el área ~/project, selecciona "Nuevo archivo" y escribe ArrayLengthCheck.java.

Ahora, abre el archivo ArrayLengthCheck.java en el editor y agrega el siguiente código:

public class ArrayLengthCheck {

    public static void main(String[] args) {
        // Declare and initialize an empty integer array
        int[] emptyArray = {};

        // Declare and initialize an integer array with elements
        int[] populatedArray = {1, 2, 3, 4, 5};

        // Check the length of the empty array
        if (emptyArray.length == 0) {
            System.out.println("emptyArray is empty.");
        } else {
            System.out.println("emptyArray is not empty. Length: " + emptyArray.length);
        }

        // Check the length of the populated array
        if (populatedArray.length == 0) {
            System.out.println("populatedArray is empty.");
        } else {
            System.out.println("populatedArray is not empty. Length: " + populatedArray.length);
        }
    }
}

Entendamos los nuevos conceptos aquí:

• int[] emptyArray = {};: Esto declara un array de enteros llamado emptyArray y lo inicializa como un array vacío.
• int[] populatedArray = {1, 2, 3, 4, 5};: Esto declara un array de enteros llamado populatedArray y lo inicializa con cinco elementos enteros.
• array.length: Esta es una propiedad de un array en Java que te da el número de elementos en el array.
• if (condition) { ... } else { ... }: Esta es una declaración if-else, una estructura fundamental de control de flujo en la programación. Permite que tu programa tome decisiones. Si la condición dentro de los paréntesis es verdadera, se ejecuta el código dentro del bloque if. De lo contrario, se ejecuta el código dentro del bloque else.

En este código, estamos utilizando la propiedad .length para verificar si la longitud de cada array es igual a 0. Si lo es, imprimimos un mensaje que indica que el array está vacío. De lo contrario, imprimimos un mensaje que indica que no está vacío y también imprimimos su longitud.

Guarda el archivo (Ctrl+S o Cmd+S).

Ahora, abre la Terminal en la parte inferior del WebIDE. Asegúrate de que estés en el directorio ~/project. Si no lo estás, utiliza el comando cd ~/project.

Compila el programa Java utilizando el comando javac:

javac ArrayLengthCheck.java

Si la compilación es exitosa, no verás salida alguna. Se creará un archivo ArrayLengthCheck.class en el directorio ~/project.

Ahora, ejecuta el programa compilado utilizando el comando java:

java ArrayLengthCheck

Deberías ver la siguiente salida:

emptyArray is empty.
populatedArray is not empty. Length: 5

Esta salida confirma que nuestro programa identificó correctamente el array vacío y el array con elementos basándose en sus longitudes. Comprobar la longitud de un array antes de intentar acceder a sus elementos es un paso crucial para prevenir errores como ArrayIndexOutOfBoundsException, que ocurre cuando intentas acceder a un elemento en un índice que no existe en el array.

Manejar arrays nulos

En el paso anterior, aprendimos cómo verificar si un array está vacío comprobando su longitud. Sin embargo, hay otro escenario importante a considerar: ¿qué pasa si el propio array es null?

En Java, una variable puede contener una referencia a un objeto, o puede contener el valor especial null, lo que significa que no se refiere a ningún objeto. Si intentas acceder a la propiedad .length de una variable de array que es null, tu programa se bloqueará con una NullPointerException. Este es un error muy común en Java, por lo que es importante saber cómo manejarlo.

Modifiquemos nuestro programa anterior para demostrar y manejar arrays null.

Abre el archivo ArrayLengthCheck.java en el editor del WebIDE.

Reemplaza el código existente con el siguiente:

public class ArrayLengthCheck {

    public static void main(String[] args) {
        // Declare an integer array but do not initialize it (it will be null)
        int[] nullArray = null;

        // Declare and initialize an empty integer array
        int[] emptyArray = {};

        // Declare and initialize an integer array with elements
        int[] populatedArray = {1, 2, 3, 4, 5};

        // Function to check if an array is null or empty
        checkArrayStatus(nullArray, "nullArray");
        checkArrayStatus(emptyArray, "emptyArray");
        checkArrayStatus(populatedArray, "populatedArray");
    }

    // A helper method to check and print the status of an array
    public static void checkArrayStatus(int[] arr, String arrayName) {
        System.out.println("Checking " + arrayName + "...");
        if (arr == null) {
            System.out.println(arrayName + " is null.");
        } else if (arr.length == 0) {
            System.out.println(arrayName + " is empty.");
        } else {
            System.out.println(arrayName + " is not empty. Length: " + arr.length);
        }
        System.out.println(); // Print a blank line for better readability
    }
}

Veamos los cambios:

• int[] nullArray = null;: Declaramos una variable de array de enteros nullArray y establecemos explícitamente su valor en null.
• public static void checkArrayStatus(int[] arr, String arrayName): Hemos creado un nuevo método llamado checkArrayStatus. Este método toma un array de enteros (arr) y una cadena (arrayName) como entrada. Esto nos ayuda a reutilizar la lógica para comprobar el estado del array.
• if (arr == null): Esta es la parte crucial para manejar arrays null. Primero comprobamos si la variable de array arr es null utilizando el operador de igualdad ==. Si es null, imprimimos un mensaje y dejamos de comprobar otras condiciones para este array.
• else if (arr.length == 0): Esta comprobación solo se realiza si el array no es null. Si el array no es null, luego comprobamos si su longitud es 0 para ver si está vacío.
• El método main ahora llama a checkArrayStatus para cada uno de nuestros arrays (nullArray, emptyArray y populatedArray).

Guarda el archivo (Ctrl+S o Cmd+S).

Abre la Terminal en el directorio ~/project.

Compila el programa Java modificado:

javac ArrayLengthCheck.java

Si la compilación es exitosa, ejecuta el programa:

java ArrayLengthCheck

Deberías ver la siguiente salida:

Checking nullArray...
nullArray is null.

Checking emptyArray...
emptyArray is empty.

Checking populatedArray...
populatedArray is not empty. Length: 5

Esta salida muestra que nuestro programa identificó correctamente el array null, el array vacío y el array con elementos. Al comprobar si es null antes de comprobar la longitud, evitamos la NullPointerException que se produciría si intentáramos acceder a .length en un array null. Esta es una práctica recomendada fundamental en la programación en Java.

Probar con diferentes tipos de arrays

En los pasos anteriores, trabajamos con un array de enteros (int[]). Es importante entender que los conceptos de comprobar si un array es null y comprobar la propiedad .length se aplican a arrays de cualquier tipo de datos en Java, ya sean tipos primitivos como int, double o boolean, o tipos de objetos como String o clases personalizadas.

Modifiquemos nuestro programa una vez más para demostrar cómo comprobar el estado de arrays de diferentes tipos.

Abre el archivo ArrayLengthCheck.java en el editor del WebIDE.

Reemplaza el código existente con el siguiente:

public class ArrayLengthCheck {

    public static void main(String[] args) {
        // Declare a null String array
        String[] nullStringArray = null;

        // Declare an empty double array
        double[] emptyDoubleArray = {};

        // Declare a boolean array with elements
        boolean[] populatedBooleanArray = {true, false, true};

        // Declare a String array with elements
        String[] populatedStringArray = {"apple", "banana", "cherry"};

        // Use the helper method to check different array types
        checkArrayStatus(nullStringArray, "nullStringArray");
        checkArrayStatus(emptyDoubleArray, "emptyDoubleArray");
        checkArrayStatus(populatedBooleanArray, "populatedBooleanArray");
        checkArrayStatus(populatedStringArray, "populatedStringArray");
    }

    // A generic helper method to check and print the status of an array
    // We use Object[] because it can represent an array of any object type
    // For primitive types, the check still works on the array reference itself
    public static void checkArrayStatus(Object arr, String arrayName) {
        System.out.println("Checking " + arrayName + "...");
        if (arr == null) {
            System.out.println(arrayName + " is null.");
        } else if (arr instanceof Object[]) {
            // For object arrays, we can cast and check length
            Object[] objectArray = (Object[]) arr;
            if (objectArray.length == 0) {
                 System.out.println(arrayName + " is empty.");
            } else {
                 System.out.println(arrayName + " is not empty. Length: " + objectArray.length);
            }
        } else if (arr.getClass().isArray()) {
             // For primitive arrays, we can't cast to Object[], but can still check length
             // using reflection or simply rely on the null check and the fact that
             // primitive arrays also have a .length property accessible directly
             // (though accessing it here would require more complex reflection)
             // For simplicity in this example, we'll just indicate it's a non-null, non-empty primitive array
             // A more robust check would involve reflection or overloaded methods for each primitive type
             try {
                 int length = java.lang.reflect.Array.getLength(arr);
                 if (length == 0) {
                     System.out.println(arrayName + " is empty.");
                 } else {
                     System.out.println(arrayName + " is not empty. Length: " + length);
                 }
             } catch (IllegalArgumentException e) {
                  System.out.println("Could not determine length for " + arrayName);
             }

        } else {
             System.out.println(arrayName + " is not an array.");
        }
        System.out.println(); // Print a blank line for better readability
    }
}

Veamos los cambios:

• Hemos creado arrays de diferentes tipos: String[], double[] y boolean[].
• El método checkArrayStatus ahora toma Object arr como parámetro. Esto le permite aceptar arrays de cualquier tipo, ya que todos los arrays en Java son objetos.
• Dentro de checkArrayStatus, primero comprobamos si arr es null.
• Si no es null, usamos instanceof Object[] para comprobar si es un array de objetos. Si lo es, lo convertimos a Object[] y comprobamos su .length.
• También agregamos una comprobación arr.getClass().isArray() para ver si el objeto es un array (esto es cierto tanto para arrays de objetos como para arrays de tipos primitivos).
• Para arrays de tipos primitivos, acceder directamente a .length dentro de este método genérico es complicado sin reflexión. El código proporcionado utiliza java.lang.reflect.Array.getLength(arr) como una forma más general de obtener la longitud de cualquier tipo de array.

Guarda el archivo (Ctrl+S o Cmd+S).

Abre la Terminal en el directorio ~/project.

Compila el programa Java modificado:

javac ArrayLengthCheck.java

Si la compilación es exitosa, ejecuta el programa:

java ArrayLengthCheck

Deberías ver una salida similar a esta:

Checking nullStringArray...
nullStringArray is null.

Checking emptyDoubleArray...
emptyDoubleArray is empty.

Checking populatedBooleanArray...
populatedBooleanArray is not empty. Length: 3

Checking populatedStringArray...
populatedStringArray is not empty. Length: 4

Esto demuestra que los principios de comprobar si un array es null y comprobar su longitud se aplican de manera consistente a diferentes tipos de arrays en Java. Si bien el método genérico checkArrayStatus que utiliza Object y reflexión es más complejo, la idea central de comprobar primero si es null y luego la longitud sigue siendo la misma para tipos de arrays específicos (como int[], String[], etc.).

Resumen

En este laboratorio, aprendimos cómo comprobar si un array en Java está vacío examinando su propiedad length. Creamos un archivo Java ArrayLengthCheck.java y escribimos código para declarar tanto arrays de enteros vacíos como con elementos. Utilizando una declaración if-else y comparando la longitud del array con cero, determinamos con éxito si cada array estaba vacío o no, imprimiendo los resultados en la consola. Esta técnica fundamental es crucial para prevenir errores cuando se trabaja con arrays.