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

JavaJavaBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderás cómo verificar si un elemento específico existe dentro de una colección en Java. Nos centraremos en utilizar el método contains(), que está disponible para todos los tipos de colecciones. Practicarás el uso de contains() con diferentes tipos de elementos y aprenderás cómo manejar elementos nulos. Al final de este laboratorio, serás proficiente en determinar la presencia de elementos dentro de colecciones Java.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java/DataStructuresGroup -.-> java/collections_methods("Collections Methods") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/encapsulation("Encapsulation") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/arraylist("ArrayList") java/SystemandDataProcessingGroup -.-> java/object_methods("Object Methods") subgraph Lab Skills java/collections_methods -.-> lab-559973{{"Cómo verificar si un conjunto contiene un elemento específico en Java"}} java/encapsulation -.-> lab-559973{{"Cómo verificar si un conjunto contiene un elemento específico en Java"}} java/arraylist -.-> lab-559973{{"Cómo verificar si un conjunto contiene un elemento específico en Java"}} java/object_methods -.-> lab-559973{{"Cómo verificar si un conjunto contiene un elemento específico en Java"}} end

Usar contains() para verificar la presencia de elementos

En este paso, exploraremos cómo verificar si un elemento específico existe dentro de una colección en Java. Las colecciones son estructuras de datos fundamentales que se utilizan para agrupar múltiples elementos en una sola unidad. Java ofrece varios tipos de colecciones, como Listas (Lists), Conjuntos (Sets) y Mapas (Maps).

Una tarea común al trabajar con colecciones es determinar si un elemento en particular está presente. La interfaz Collection de Java, que es la interfaz raíz para todos los tipos de colecciones, proporciona un método conveniente para este propósito: contains().

El método contains() toma un argumento, el elemento que deseas verificar, y devuelve un valor booleano: true si el elemento se encuentra en la colección y false en caso contrario.

Vamos a crear un sencillo programa en Java para demostrar cómo usar el método contains() con un ArrayList, que es un tipo común de Lista.

  1. Abre el archivo HelloJava.java en el editor WebIDE si no está abierto.

  2. Reemplaza todo el contenido del archivo con el siguiente código:

    import java.util.ArrayList;
    import java.util.List;
    
    public class HelloJava {
        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);
        }
    }

    Analicemos este nuevo código:

    • import java.util.ArrayList; y import java.util.List;: Estas líneas importan las clases necesarias para trabajar con Listas y ArrayLists.
    • List<String> fruits = new ArrayList<>();: Esta línea crea un nuevo ArrayList que puede contener objetos String y lo asigna a una variable llamada fruits.
    • fruits.add("Apple"); y líneas similares: Estas líneas agregan elementos (cadenas que representan nombres de frutas) a nuestra lista fruits.
    • boolean hasBanana = fruits.contains("Banana");: Esta línea llama al método contains() en la lista fruits, verificando si la cadena "Banana" está presente. El resultado (true o false) se almacena en una variable booleana hasBanana.
    • System.out.println("Does the list contain Banana? " + hasBanana);: Esta línea imprime el resultado de la verificación de "Banana".
    • boolean hasGrape = fruits.contains("Grape"); y la siguiente línea println: Estas líneas realizan la misma verificación para "Grape", que no está en nuestra lista.
  3. Guarda el archivo (Ctrl+S o Cmd+S).

  4. Compila el programa modificado en la Terminal:

    javac HelloJava.java
  5. Ejecuta el programa compilado:

    java HelloJava

    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 que "Banana" está en la lista y "Grape" no.

Comprender cómo verificar la presencia de elementos es una habilidad fundamental al trabajar con colecciones en Java. En los siguientes pasos, exploraremos más aspectos del método contains() y cómo se comporta en diferentes escenarios.

Prueba con diferentes tipos de elementos

En el paso anterior, utilizamos el método contains() con una List de objetos String. El método contains() es versátil y se puede utilizar con colecciones que almacenan diferentes tipos de elementos, como números, objetos personalizados o incluso otras colecciones.

Al utilizar contains(), Java se basa en el método equals() de los objetos dentro de la colección para determinar si el elemento que se está buscando coincide. Para los tipos primitivos (como int, double, boolean), se utilizan sus correspondientes clases envoltorio (Integer, Double, Boolean), y sus métodos equals() comparan los valores. Para los objetos, el método equals() predeterminado comprueba si las dos referencias de objeto apuntan a la misma ubicación de memoria. Sin embargo, muchas clases (como String, Integer, etc.) sobrescriben el método equals() para comparar el contenido o valor real de los objetos.

Modifiquemos nuestro programa para trabajar con una List de objetos Integer y veamos cómo se comporta contains().

  1. Abre el archivo HelloJava.java en el editor WebIDE.

  2. Reemplaza el código actual con el siguiente:

    import java.util.ArrayList;
    import java.util.List;
    
    public class HelloJava {
        public static void main(String[] args) {
            // Create a List of integers
            List<Integer> numbers = new ArrayList<>();
    
            // Add some numbers to the list
            numbers.add(10);
            numbers.add(25);
            numbers.add(5);
            numbers.add(50);
    
            // Check if the list contains 25
            boolean hasTwentyFive = numbers.contains(25);
            System.out.println("Does the list contain 25? " + hasTwentyFive);
    
            // Check if the list contains 100
            boolean hasOneHundred = numbers.contains(100);
            System.out.println("Does the list contain 100? " + hasOneHundred);
    
            // Check if the list contains the Integer object with value 5
            boolean hasFiveObject = numbers.contains(Integer.valueOf(5));
            System.out.println("Does the list contain Integer object with value 5? " + hasFiveObject);
        }
    }

    En este código:

    • Creamos una List que específicamente almacena objetos Integer: List<Integer> numbers = new ArrayList<>();.
    • Agregamos valores enteros a la lista utilizando numbers.add(). Java convierte automáticamente los valores int primitivos (10, 25, 5, 50) en objetos Integer (esto se llama autoboxing).
    • Utilizamos numbers.contains(25) y numbers.contains(100) para verificar la presencia de valores enteros. Nuevamente, Java convierte automáticamente los valores int primitivos 25 y 100 en objetos Integer antes de realizar la comprobación.
    • También creamos explícitamente un objeto Integer utilizando Integer.valueOf(5) y verificamos si la lista contiene este objeto específico.
  3. Guarda el archivo.

  4. Compila el programa en la Terminal:

    javac HelloJava.java
  5. Ejecuta el programa:

    java HelloJava

    Deberías ver una salida similar a esta:

    Does the list contain 25? true
    Does the list contain 100? false
    Does the list contain Integer object with value 5? true

Esto demuestra que contains() funciona correctamente con objetos Integer, comparando sus valores. El método contains() utiliza efectivamente el método equals() de los elementos de la colección y del elemento que se está buscando.

En el siguiente paso, exploraremos un caso especial: manejar elementos null con el método contains().

Manejar elementos nulos

En Java, las colecciones a veces pueden contener elementos null. Es importante entender cómo se comporta el método contains() cuando se trata de null.

La buena noticia es que el método contains() está diseñado para manejar elementos null de manera adecuada. Si una colección contiene null, llamar a contains(null) devolverá true. Si la colección no contiene null, devolverá false. Esto es consistente con cómo se implementa generalmente equals() para null (el equals(null) de cualquier objeto debe devolver false, pero null.equals(anyObject) lanzaría una NullPointerException si no se maneja internamente por la implementación de contains de la colección).

Modifiquemos nuestro programa para incluir y verificar elementos null.

  1. Abre el archivo HelloJava.java en el editor WebIDE.

  2. Reemplaza el código actual con el siguiente:

    import java.util.ArrayList;
    import java.util.List;
    
    public class HelloJava {
        public static void main(String[] args) {
            // Create a List that can contain null
            List<String> mixedList = new ArrayList<>();
    
            // Add some elements, including null
            mixedList.add("First");
            mixedList.add(null); // Adding a null element
            mixedList.add("Second");
            mixedList.add(null); // Adding another null element
            mixedList.add("Third");
    
            // Check if the list contains null
            boolean hasNull = mixedList.contains(null);
            System.out.println("Does the list contain null? " + hasNull);
    
            // Check if the list contains a non-existent element
            boolean hasFourth = mixedList.contains("Fourth");
            System.out.println("Does the list contain Fourth? " + hasFourth);
    
            // Check if the list contains "First"
            boolean hasFirst = mixedList.contains("First");
            System.out.println("Does the list contain First? " + hasFirst);
        }
    }

    En este código:

    • Creamos una List llamada mixedList.
    • Agregamos algunos elementos String y también agregamos explícitamente null utilizando mixedList.add(null);.
    • Luego usamos mixedList.contains(null) para verificar si la lista contiene el valor null.
    • También realizamos comprobaciones para una cadena que no existe ("Fourth") y una cadena existente ("First") para ver los resultados junto con la comprobación de null.
  3. Guarda el archivo.

  4. Compila el programa en la Terminal:

    javac HelloJava.java
  5. Ejecuta el programa:

    java HelloJava

    Deberías ver una salida similar a esta:

    Does the list contain null? true
    Does the list contain Fourth? false
    Does the list contain First? true

Esta salida confirma que contains() identifica correctamente la presencia de null dentro de la lista. Es importante tener en cuenta que las colecciones pueden contener null (dependiendo del tipo de colección específico y cómo se utiliza), y contains() proporciona una forma confiable de verificarlo.

Ahora has aprendido cómo usar el método contains() para verificar la presencia de elementos en colecciones Java, incluyendo diferentes tipos de datos y el caso especial de null. Esta es una herramienta valiosa para trabajar con colecciones en tus programas Java.

Resumen

En este laboratorio, aprendimos cómo verificar si una colección contiene un elemento específico en Java utilizando el método contains(). Vimos cómo este método, disponible a través de la interfaz Collection, devuelve un valor booleano que indica la presencia del elemento. Demostramos su uso con un ArrayList y observamos cómo identifica correctamente los elementos existentes y no existentes.

También exploramos cómo funciona el método contains() con diferentes tipos de datos y cómo manejar elementos nulos dentro de una colección. Esta experiencia práctica proporcionó una comprensión práctica de una operación fundamental al trabajar con colecciones Java.