Cómo comprobar si una matriz (array) 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 matriz (array) de Java utilizando diferentes técnicas. Comenzaremos explorando el enfoque fundamental de iterar a través de la matriz utilizando un bucle for tradicional para buscar el elemento.

Después del método básico de iteración, descubrirás cómo aprovechar el método Arrays.stream() para una forma más concisa y potencialmente más eficiente de verificar la presencia del elemento. Finalmente, abordaremos la importante consideración de manejar elementos nulos dentro de la matriz durante tus operaciones de búsqueda.

Recorrer la matriz (array) en busca de un elemento

En este paso, aprenderás cómo verificar si un elemento específico existe dentro de una matriz (array) de Java recorriéndola utilizando un bucle for tradicional. Esta es una técnica fundamental para buscar dentro de colecciones de datos.

Primero, creemos un nuevo archivo Java llamado ArraySearch.java en tu directorio ~/project. Puedes hacer esto utilizando el explorador de archivos de WebIDE en el lado izquierdo o ejecutando el siguiente comando en la terminal:

touch ~/project/ArraySearch.java

Ahora, abre el archivo ArraySearch.java en el editor de WebIDE y agrega el siguiente código Java:

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Variable to keep track if the element is found
        boolean found = false;

        // Loop through the array
        for (int i = 0; i < fruits.length; i++) {
            // Check if the current element is equal to the search element
            if (fruits[i].equals(searchElement)) {
                found = true; // Element found
                break; // Exit the loop since we found the element
            }
        }

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }
    }
}

Desglosemos este código:

• String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};: Esta línea declara e inicializa una matriz (array) de cadenas llamada fruits con varios nombres de frutas.
• String searchElement = "Cherry";: Esta línea declara una variable de tipo cadena searchElement y le asigna el valor "Cherry". Este es el elemento que estamos buscando en la matriz.
• boolean found = false;: Esta línea declara una variable booleana found y la inicializa en false. Estableceremos esto en true si encontramos el searchElement en la matriz.
• for (int i = 0; i < fruits.length; i++): Este es un bucle for estándar que recorre la matriz. i comienza en 0 y aumenta hasta (pero sin incluir) la longitud de la matriz fruits.
• if (fruits[i].equals(searchElement)): Dentro del bucle, esta instrucción if verifica si el elemento actual de la matriz (fruits[i]) es igual al searchElement. Usamos el método .equals() para comparar cadenas en Java, no el operador ==.
• found = true;: Si los elementos son iguales, establecemos la variable found en true.
• break;: Una vez que se encuentra el elemento, usamos la instrucción break para salir del bucle antes, ya que no es necesario seguir buscando.
• El bloque if/else final imprime un mensaje que indica si se encontró el searchElement según el valor de la variable found.

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

Ahora, compilaremos y ejecutaremos el programa en la terminal. Asegúrate de estar en el directorio ~/project.

Compila el código:

javac ArraySearch.java

Si no hay errores, se creará un archivo ArraySearch.class.

Ejecuta el código compilado:

java ArraySearch

Deberías ver la siguiente salida:

Cherry was found in the array.

Ahora, intenta cambiar el searchElement a algo que no esté en la matriz, como "Grape", guarda el archivo, vuelve a compilar y ejecútalo de nuevo para ver la salida diferente.

Utilizar Arrays.stream() para comprobar la presencia de un elemento

En este paso, aprenderás una forma más moderna y a menudo más concisa de verificar si un elemento está presente en una matriz (array) de Java utilizando la API de Streams, específicamente Arrays.stream(). Este enfoque aprovecha conceptos de programación funcional y puede hacer que tu código sea más legible para ciertas tareas.

Modificaremos el archivo ArraySearch.java que creaste en el paso anterior. Abre ~/project/ArraySearch.java en el editor de WebIDE.

Reemplaza el código existente con lo siguiente:

import java.util.Arrays;

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Use Arrays.stream() to check if the element exists
        boolean found = Arrays.stream(fruits).anyMatch(fruit -> fruit.equals(searchElement));

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }
    }
}

Veamos los cambios:

• import java.util.Arrays;: Necesitamos importar la clase Arrays para utilizar su método stream().
• boolean found = Arrays.stream(fruits).anyMatch(fruit -> fruit.equals(searchElement));: Este es el núcleo del nuevo enfoque.
  • Arrays.stream(fruits): Esto convierte la matriz fruits en un Stream. Un stream es una secuencia de elementos que admite diversas operaciones.
  • .anyMatch(fruit -> fruit.equals(searchElement)): Esta es una operación de stream. anyMatch() verifica si algún elemento del stream coincide con la condición dada. La condición se proporciona como una expresión lambda fruit -> fruit.equals(searchElement). Esta expresión lambda toma cada fruit del stream y verifica si es igual al searchElement. Si se encuentra una coincidencia, anyMatch() devuelve true inmediatamente.

Este enfoque basado en streams logra el mismo resultado que el bucle for, pero en un estilo más declarativo: describir qué quieres hacer (encontrar si algún elemento coincide con la condición) en lugar de cómo hacerlo (iterar paso a paso).

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

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

Compila el código:

javac ArraySearch.java

Ejecuta el código compilado:

java ArraySearch

Deberías ver la misma salida que antes:

Cherry was found in the array.

Nuevamente, siéntete libre de cambiar el searchElement para probar el caso else.

Manejar elementos nulos

En este paso, consideraremos un escenario común en Java: tratar con valores null en matrices (arrays). Si una matriz contiene elementos null, nuestros métodos anteriores podrían encontrar problemas. Aprenderemos cómo manejar de forma segura los valores null al buscar un elemento.

Abre nuevamente el archivo ~/project/ArraySearch.java en el editor de WebIDE.

Modifica la matriz fruits para incluir un elemento null:

import java.util.Arrays;
import java.util.Objects; // Import the Objects class

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings with a null element
        String[] fruits = {"Apple", null, "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Use Arrays.stream() and handle nulls
        boolean found = Arrays.stream(fruits)
                              .anyMatch(fruit -> Objects.equals(fruit, searchElement)); // Use Objects.equals

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }

        // Let's also search for null itself
        String searchNullElement = null;
        boolean foundNull = Arrays.stream(fruits)
                                  .anyMatch(fruit -> Objects.equals(fruit, searchNullElement));

        if (foundNull) {
            System.out.println("null was found in the array.");
        } else {
            System.out.println("null was not found in the array.");
        }
    }
}

Esto es lo que hemos cambiado:

• import java.util.Objects;: Importamos la clase Objects, que proporciona métodos de utilidad para objetos, incluyendo el manejo seguro de null.
• String[] fruits = {"Apple", null, "Banana", "Cherry", "Date", "Elderberry"};: Agregamos null como el segundo elemento en la matriz fruits.
• .anyMatch(fruit -> Objects.equals(fruit, searchElement)): En lugar de fruit.equals(searchElement), ahora usamos Objects.equals(fruit, searchElement). El método Objects.equals() está diseñado para manejar valores null de manera adecuada. Devuelve true si ambos argumentos son null, y evita lanzar una NullPointerException si el primer argumento (fruit en este caso) es null.
• Agregamos una segunda búsqueda para demostrar cómo encontrar null en sí mismo en la matriz utilizando el mismo método Objects.equals().

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

Compila y ejecuta el programa modificado en la terminal desde el directorio ~/project:

Compila el código:

javac ArraySearch.java

Ejecuta el código compilado:

java ArraySearch

Deberías ver la siguiente salida, que demuestra que tanto "Cherry" como null se encontraron:

Cherry was found in the array.
null was found in the array.

Usar Objects.equals() es la forma recomendada de comparar objetos, especialmente cuando existe la posibilidad de que uno o ambos objetos sean null. Esto evita errores inesperados de NullPointerException.

Resumen

En este laboratorio (lab), aprendiste un método fundamental para verificar si un elemento específico existe dentro de una matriz (array) de Java: iterar a través de la matriz utilizando un bucle for tradicional. Practicaste la creación de un archivo Java, la definición de una matriz y un elemento de búsqueda, la implementación del bucle para comparar elementos y el uso de una bandera booleana para rastrear si el elemento fue encontrado. Este ejercicio práctico demostró cómo realizar una operación de búsqueda básica e imprimir el resultado en función de si el elemento estaba presente en la matriz.