No soy adivino, pero estoy casi seguro de que en algún momento tendrás que desarrollar una aplicación donde debas verificar si un conjunto de elementos contiene ciertos datos, como usuarios, valores únicos o cadenas específicas. Cuando ese momento llegue, quiero que estés preparado y sepas usar correctamente HashSet.contains() en Java. Créeme que se convertirá prácticamente en tu mejor amigo para comprobar rápidamente si un elemento existe dentro de un conjunto. Quédate porque quiero contarte qué es y cómo se utiliza.

¿Qué encontrarás en este post?

¿Qué es HashSet.contains() en Java?

HashSet.contains() en Java es un método que puedes usar para darte cuenta si un elemento específico está presente en el conjunto. Es muy bueno para validar la existencia de un valor sin necesidad de recorrer manualmente la colección.

Este método es algo así como tener una colección de sellos postales en un álbum, donde cada sello es único. Cuando usas HashSet.contains() prácticamente le estás diciendo al álbum: “Oye, ¿este sello ya existe en la colección?”

Sintaxis

public boolean contains(Object element)

Parámetros

element: Este sería el objeto que quieres verificar si existe en el conjunto. No olvides que, debe ser del mismo tipo que el definido en el HashSet.

Valor de retorno

true: Cuando el elemento está presente en el conjunto.
false: Si el elemento no está en el conjunto.

¿Cómo usar HashSet.contains() en Java? Ejemplos prácticos

Quiero dejarte unos ejemplos prácticos que a mí me ayudaron en su momento, para manejar como un experto el método HashSet.contains() en Java:

Verificación básica con cadenas

Como no quiero abrumarte, vas a iniciar con un ejemplo muy facilito, para que comprendas bien cómo funciona este método:

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> colores = new HashSet<>();
        
        colores.add("Rojo");
        colores.add("Azul");
        colores.add("Verde");

        System.out.println("¿El conjunto contiene 'Azul'? " + colores.contains("Azul"));
        System.out.println("¿El conjunto contiene 'Amarillo'? " + colores.contains("Amarillo"));
    }
}

Así debe verse la salida:

¿El conjunto contiene 'Azul'? true
¿El conjunto contiene 'Amarillo'? false

Mira que, contains(“Azul”) devuelve true porque “Azul” está en el conjunto, mientras que “Amarillo” no.

Comprobando números en un HashSet

Ahora quiero mostrarte cómo usar HashSet.contains() en Java con números enteros. Es simple, mira:

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<Integer> numeros = new HashSet<>();
        
        numeros.add(10);
        numeros.add(20);
        numeros.add(30);

        System.out.println("¿El conjunto contiene 20? " + numeros.contains(20));
        System.out.println("¿El conjunto contiene 40? " + numeros.contains(40));
    }
}

Observa la salida:

¿El conjunto contiene 20? true
¿El conjunto contiene 40? false

Uso con objetos personalizados

Para que contains() funcione como es, hay que sobrescribir los métodos equals y hashCode si vamos a trabajar con objetos personalizados.

import java.util.HashSet;

class Persona {
    String nombre;

    public Persona(String nombre) {
        this.nombre = nombre;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Persona persona = (Persona) obj;
        return nombre.equals(persona.nombre);
    }

    @Override
    public int hashCode() {
        return nombre.hashCode();
    }
}

public class Main {
    public static void main(String[] args) {
        HashSet<Persona> personas = new HashSet<>();
        
        personas.add(new Persona("Juan"));
        personas.add(new Persona("Ana"));

        System.out.println("¿El conjunto contiene a 'Ana'? " + personas.contains(new Persona("Ana")));
        System.out.println("¿El conjunto contiene a 'Luis'? " + personas.contains(new Persona("Luis")));
    }
}

Esta es la salida:

¿El conjunto contiene a 'Ana'? true
¿El conjunto contiene a 'Luis'? false

Aprovecha al máximo HashSet.contains() en Java con estos consejos

No eches en saco roto estos consejos que te voy a dar, porque de verdad sirven demasiado a la hora de usar HashSet.contains():

Sobrescribe equals y hashCode: Hago énfasis en esto porque es muy importante. Sobrescribe estos métodos si vas a trabajar con objetos personalizados, así evitarás resultados incorrectos.
Evita elementos nulos: Aunque HashSet permite elementos nulos, me ha pasado que al usarlos obtengo excepciones al verificar su existencia.
Utiliza tipos consistentes: Ojo aquí, porque el objeto que verificas debe ser del mismo tipo que los elementos en el HashSet.

Me parece grandioso que, ya no lucharás más para verificar la existencia de elementos en un conjunto, porque ahora sabes manejar el método HashSet.contains() en Java. Es un alivio, ¿no? Además, con ejemplos como los que hemos visto, puedes implementarlo en tus proyectos fácilmente y evitar errores comunes.

¿Quieres dejar de estar estancado a nivel profesional? Pues esta noticia te animará y mucho. Resulta que, en el Bootcamp de Java Full Stack de KeepCoding aprenderás desde las bases hasta temas avanzados como estructuras de datos y desarrollo web en menos de lo que te imaginas. Así que, por nada del mundo dejes pasar esta oportunidad de transformar tu carrera.