Cómo comprobar si una lista contiene elementos nulos en Java

Introducción

En este laboratorio (lab), aprenderás cómo verificar si una List de Java contiene elementos null. Exploraremos diferentes métodos para lograr esto, comenzando con el sencillo método contains(). Aprenderás cómo usar contains(null) para determinar rápidamente la presencia de un valor nulo en una lista.

Después de la comprobación inicial, el laboratorio te guiará a través de la iteración sobre una lista para comprobar manualmente cada elemento en busca de valores nulos. Este enfoque brinda más control y permite manejar escenarios con múltiples elementos nulos, que también se cubrirán. Al final de este laboratorio, tendrás una comprensión sólida de varias técnicas para identificar valores nulos dentro de listas de Java.

Skills Graph

Usar contains() para la comprobación de valores nulos

En este paso, exploraremos cómo comprobar la presencia de elementos null dentro de una List de Java utilizando el método contains(). Si bien contains() se utiliza generalmente para comprobar la presencia de elementos específicos, también se puede utilizar para verificar si una List contiene null.

Primero, creemos un nuevo archivo Java. En el Explorador de archivos de la izquierda, haz clic derecho en el directorio ~/project, selecciona "Nuevo archivo" y asígnalo el nombre NullCheckList.java.

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

import java.util.List;
import java.util.ArrayList;

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");

        // Check if the list contains null using contains()
        boolean containsNull = names.contains(null);

        // Print the result
        System.out.println("Does the list contain null? " + containsNull);
    }
}

Desglosemos las nuevas partes de este código:

• import java.util.List; y import java.util.ArrayList;: Estas líneas importan las clases necesarias para trabajar con List y ArrayList.
• List<String> names = new ArrayList<>();: Esto crea una nueva ArrayList que puede contener objetos String. La declaramos como List porque List es una interfaz que ArrayList implementa.
• names.add(null);: Esta línea agrega explícitamente un valor null a nuestra lista.
• boolean containsNull = names.contains(null);: Este es el núcleo de este paso. Llamamos al método contains() en la lista names, pasando null como argumento. El método devuelve true si la lista contiene null, y false en caso contrario. El resultado se almacena en una variable booleana containsNull.
• System.out.println("Does the list contain null? " + containsNull);: Esta línea imprime el resultado de nuestra comprobación en la consola.

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

Ahora, compilemos y ejecutemos el programa. Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project.

Compila el código utilizando javac:

javac NullCheckList.java

Si la compilación es exitosa (la ausencia de salida significa éxito), ejecuta el código compilado utilizando java:

java NullCheckList

Deberías ver una salida que indique si la lista contiene null.

Recorrer la lista en busca de valores nulos

En el paso anterior, utilizamos el método contains() para comprobar si una lista contiene null. Aunque es sencillo, este método solo nos dice si null está presente, no dónde está o cuántas veces aparece. Una forma más común y flexible de manejar elementos null en una lista es recorrer la lista utilizando un bucle y comprobar cada elemento individualmente.

En este paso, modificaremos nuestro programa NullCheckList.java para recorrer la lista e identificar la posición (índice) de cualquier elemento null.

Abre el archivo NullCheckList.java en el editor del WebIDE. Reemplaza el método main existente con el siguiente código:

import java.util.List;
import java.util.ArrayList;

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");
        names.add("Charlie");
        names.add(null); // Adding another null element

        System.out.println("Checking list for null elements:");

        // Loop through the list using a for loop
        for (int i = 0; i < names.size(); i++) {
            // Get the element at the current index
            String name = names.get(i);

            // Check if the element is null
            if (name == null) {
                System.out.println("Null found at index: " + i);
            }
        }
    }
}

Veamos los cambios:

• Agregamos otro elemento null a la lista para demostrar cómo encontrar múltiples valores null.
• for (int i = 0; i < names.size(); i++): Este es un bucle for estándar que itera desde el índice 0 hasta (pero sin incluir) el tamaño de la lista names. La variable i representa el índice actual.
• String name = names.get(i);: Dentro del bucle, names.get(i) recupera el elemento en el índice actual i y lo almacena en la variable name.
• if (name == null): Esta es la comprobación crucial. Utilizamos el operador de igualdad == para comparar la variable name con null. Si son iguales, significa que el elemento en el índice actual es null.
• System.out.println("Null found at index: " + i);: Si se encuentra un valor null, esta línea imprime un mensaje que indica el índice donde se encontró.

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

Ahora, compila y ejecuta el programa modificado desde la Terminal en el directorio ~/project:

javac NullCheckList.java

java NullCheckList

Deberías ver una salida que indique los índices donde se encontraron elementos null en la lista.

Checking list for null elements:
Null found at index: 1
Null found at index: 4

Este enfoque nos brinda información más detallada sobre los elementos null en la lista, lo cual a menudo es necesario para manejarlos adecuadamente en tu programa.

Manejar múltiples elementos nulos

En el paso anterior, recorrimos exitosamente una lista e identificamos los índices de los elementos null. Ahora, expandamos eso y demos un ejemplo de cómo se pueden manejar estos elementos null. "Manejar" puede significar diferentes cosas dependiendo de la lógica de tu programa, como omitir el elemento null, reemplazarlo con un valor predeterminado o realizar una acción específica.

En este paso, modificaremos nuevamente nuestro programa NullCheckList.java. Esta vez, recorreremos la lista e imprimiremos un mensaje diferente para los elementos no nulos en comparación con los elementos nulos.

Abre el archivo NullCheckList.java en el editor del WebIDE. Reemplaza el método main existente con el siguiente código:

import java.util.List;
import java.util.ArrayList;

public class NullCheckList {

    public static void main(String[] args) {
        // Create a List and add some elements, including null
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add(null); // Adding a null element
        names.add("Bob");
        names.add("Charlie");
        names.add(null); // Adding another null element
        names.add("David");

        System.out.println("Processing list elements:");

        // Loop through the list using a for-each loop
        for (String name : names) {
            // Check if the element is null
            if (name == null) {
                System.out.println("Found a null element, skipping.");
            } else {
                // If the element is not null, process it
                System.out.println("Processing name: " + name);
            }
        }
    }
}

Veamos los cambios en esta versión:

• Agregamos un elemento no nulo más ("David") a la lista.
• for (String name : names): Este es un bucle for mejorado (también conocido como bucle for-each). Es una forma conveniente de iterar sobre los elementos de una colección sin usar un índice. En cada iteración, la variable name contendrá el elemento actual de la lista names.
• if (name == null): Todavía usamos el operador == para comprobar si el elemento actual (name) es null.
• System.out.println("Found a null element, skipping.");: Si el elemento es null, imprimimos un mensaje que indica que lo estamos omitiendo. En una aplicación real, podrías realizar una acción diferente aquí, como registrar el valor nulo o asignar un valor predeterminado.
• else { System.out.println("Processing name: " + name); }: Si el elemento no es null, entramos en el bloque else e imprimimos un mensaje que indica que estamos procesando el nombre no nulo.

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

Ahora, compila y ejecuta el programa modificado desde la Terminal en el directorio ~/project:

javac NullCheckList.java

java NullCheckList

Deberías ver una salida que procese los nombres no nulos e indique cuando se encuentra un elemento nulo.

Processing list elements:
Processing name: Alice
Found a null element, skipping.
Processing name: Bob
Processing name: Charlie
Found a null element, skipping.
Processing name: David

Este ejemplo demuestra una forma básica de manejar elementos null durante la iteración. Dependiendo de tus necesidades específicas, podrías reemplazar null con una cadena predeterminada, eliminar los elementos null de la lista o realizar otras operaciones. Lo importante es comprobar si hay un null antes de intentar usar el elemento, ya que intentar llamar a métodos en un objeto null resultará en una NullPointerException.

Resumen

En este laboratorio, aprendimos cómo comprobar si una List de Java contiene elementos nulos. Exploramos el uso del método contains() con null como argumento, que ofrece una forma sencilla de determinar la presencia de un solo elemento nulo.

Creamos una ArrayList de muestra, agregamos tanto elementos válidos como un valor nulo, y luego usamos names.contains(null) para realizar la comprobación. El resultado se imprimió en la consola, demostrando la eficacia de este método para una comprobación básica de valores nulos dentro de una lista.