Cómo verificar si una lista contiene un elemento específico en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un elemento específico existe dentro de una List de Java. Exploraremos diferentes métodos para realizar esta tarea común cuando se trabaja con colecciones de datos.

Primero aprenderás a utilizar el conveniente método contains() proporcionado por la interfaz List. Después de eso, entenderás cómo iterar manualmente a través de una lista para buscar un elemento, lo cual puede ser útil en ciertos escenarios. Finalmente, cubriremos cómo manejar la presencia de elementos nulos dentro de tu lista cuando realices estas comprobaciones.

Skills Graph

Usar contains() para verificar la existencia de un elemento

En este paso, aprenderemos cómo verificar si un elemento específico existe en una List de Java utilizando el método contains(). Esta es una tarea común cuando se trabaja con colecciones de datos.

Primero, creemos un nuevo archivo Java llamado ListContains.java en tu directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda y seleccionando "Nuevo archivo", luego escribiendo ListContains.java.

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

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

public class ListContains {

    public static void main(String[] args) {
        // Create a List of strings
        List<String> fruits = new ArrayList<>();

        // Add some fruits to the list
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Mango");

        // Check if the list contains "Banana"
        boolean hasBanana = fruits.contains("Banana");
        System.out.println("Does the list contain Banana? " + hasBanana);

        // Check if the list contains "Grape"
        boolean hasGrape = fruits.contains("Grape");
        System.out.println("Does the list contain Grape? " + hasGrape);
    }
}

Desglosemos este código:

• import java.util.ArrayList; y import java.util.List;: Estas líneas importan las clases necesarias para trabajar con listas.
• List<String> fruits = new ArrayList<>();: Esta línea crea una nueva ArrayList, que es un tipo de List que puede contener objetos String.
• fruits.add("...");: Estas líneas agregan elementos (nombres de frutas) a nuestra lista.
• fruits.contains("Banana");: Este es el núcleo de este paso. El método contains() se llama en la lista fruits. Toma un argumento, el elemento que queremos verificar. Devuelve true si el elemento se encuentra en la lista y false en caso contrario.
• boolean hasBanana = ...;: El resultado de contains() se almacena en una variable booleana (hasBanana o hasGrape).
• System.out.println("...");: Estas líneas imprimen los resultados en la consola.

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

Ahora, abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project. Si no lo estás, escribe cd ~/project y presiona Enter.

Compila el código Java utilizando el comando javac:

javac ListContains.java

Si no hay errores, se creará un archivo ListContains.class en el directorio ~/project.

Finalmente, ejecuta el programa Java compilado utilizando el comando java:

java ListContains

Deberías ver una salida similar a esta:

Does the list contain Banana? true
Does the list contain Grape? false

Esta salida confirma que el método contains() identificó correctamente si "Banana" y "Grape" estaban presentes en nuestra lista.

Recorrer una lista manualmente

En el paso anterior, utilizamos el método contains() para verificar la existencia de un elemento. Si bien contains() es conveniente, a veces es necesario examinar cada elemento de una lista uno por uno. Esto se llama iterar o recorrer una lista. En este paso, aprenderemos cómo hacerlo utilizando un bucle for.

Abre el archivo ListContains.java en tu directorio ~/project en el editor del WebIDE.

Modificaremos el código existente para recorrer la lista fruits e imprimir cada elemento. Reemplaza el método main existente con el siguiente código:

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

public class ListContains {

    public static void main(String[] args) {
        // Create a List of strings
        List<String> fruits = new ArrayList<>();

        // Add some fruits to the list
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Mango");

        // Loop through the list using a for loop
        System.out.println("Printing fruits in the list:");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);
            System.out.println(fruit);
        }
    }
}

Veamos las nuevas partes:

• System.out.println("Printing fruits in the list:");: Esta línea simplemente imprime un encabezado antes de comenzar a enumerar las frutas.
• for (int i = 0; i < fruits.size(); i++): Este es un bucle for estándar.
  • int i = 0: Iniciamos una variable contador i en 0. En programación, a menudo comenzamos a contar desde 0.
  • i < fruits.size(): El bucle continúa mientras i sea menor que el número total de elementos en la lista fruits. fruits.size() nos da el número de elementos.
  • i++: Después de cada ejecución del bucle, aumentamos el valor de i en 1.
• String fruit = fruits.get(i);: Dentro del bucle, fruits.get(i) recupera el elemento en la posición actual i de la lista. Almacenamos este elemento en una variable String llamada fruit.
• System.out.println(fruit);: Esta línea imprime la fruta actual en la consola.

Guarda el archivo ListContains.java.

Ahora, compila el código modificado en la Terminal:

javac ListContains.java

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

java ListContains

Deberías ver la siguiente salida:

Printing fruits in the list:
Apple
Banana
Orange
Mango

Esto muestra que nuestro bucle for recorrió con éxito la lista e imprimió cada fruta en una nueva línea. Recorrer manualmente una lista de esta manera te da más control sobre cómo procesas cada elemento, lo cual puede ser útil para tareas más complejas que simplemente verificar la existencia.

Manejar elementos nulos en una lista

En el mundo real, las listas a veces pueden contener valores "nulos", que representan la ausencia de un valor. Si intentas realizar operaciones en un valor nulo sin comprobarlo, tu programa puede fallar con una NullPointerException. En este paso, aprenderemos cómo manejar elementos nulos cuando recorremos una lista.

Abre el archivo ListContains.java en tu directorio ~/project en el editor del WebIDE.

Modificaremos el código para agregar un elemento null a la lista y luego comprobar si hay valores nulos dentro del bucle. Reemplaza el método main existente con el siguiente código:

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

public class ListContains {

    public static void main(String[] args) {
        // Create a List of strings
        List<String> fruits = new ArrayList<>();

        // Add some fruits to the list, including a null
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add(null); // Adding a null element
        fruits.add("Orange");
        fruits.add("Mango");

        // Loop through the list and handle null elements
        System.out.println("Printing fruits in the list (handling nulls):");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);

            // Check if the element is null before processing
            if (fruit != null) {
                System.out.println(fruit);
            } else {
                System.out.println("Found a null element");
            }
        }
    }
}

Esto es lo que hemos cambiado:

• fruits.add(null);: Hemos agregado un valor null a la lista.
• if (fruit != null): Dentro del bucle, antes de intentar imprimir la fruta, agregamos una instrucción if para comprobar si la variable fruit no es nula.
• System.out.println(fruit);: Esta línea está dentro del bloque if, por lo que solo se ejecutará si fruit no es nulo.
• else { System.out.println("Found a null element"); }: Este bloque else se ejecuta si fruit es nulo, imprimiendo un mensaje en lugar de intentar imprimir el valor nulo en sí.

Guarda el archivo ListContains.java.

Compila el código modificado en la Terminal:

javac ListContains.java

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

java ListContains

Deberías ver la siguiente salida:

Printing fruits in the list (handling nulls):
Apple
Banana
Found a null element
Orange
Mango

Como puedes ver, el programa ahora identifica y maneja correctamente el elemento nulo sin fallar. Comprobar si hay valores nulos es una práctica crucial en la programación en Java para prevenir errores y hacer que tus programas sean más robustos.

Resumen

En este laboratorio, aprendimos cómo verificar si una List de Java contiene un elemento específico. Primero exploramos el método más sencillo, utilizando el método incorporado contains(), que determina de manera eficiente la presencia de un elemento y devuelve un resultado booleano.

Luego profundizamos en la iteración manual a través de la lista para realizar la comprobación, lo que nos brindó una comprensión más profunda de cómo podría funcionar internamente el método contains(). Finalmente, abordamos la importante consideración de manejar elementos nulos dentro de la lista al realizar estas comprobaciones, asegurando un código robusto y libre de errores.