Aprende a usar HashSet.remove() en Java para eliminar elementos

Cierto día me encontraba trabajando en un proyecto en Java donde tenía que gestionar un conjunto de datos sin duplicados. Me sentía muy confiado de mis conocimientos, pero cuando me tocó eliminar elementos, no supe cómo hacerlo y me frustré. Por suerte, me enseñaron a usar HashSet.remove() en Java para solucionar este problema y mejoré drásticamente mis habilidades con las colecciones. Entonces, yo también voy a enseñarte de una forma fácil de entender, cómo usar este método para eliminar elementos sin que te tome una eternidad.

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

HashSet.remove() en Java es un método con el que puedes eliminar un elemento específico de un HashSet. Algo importante es que, si el elemento existe en la colección, lo elimina y devuelve true, pero si no existe, te devolverá false.

Haz de cuenta que tienes una caja de juguetes y cada juguete tiene un lugar especial dentro de la caja. Cuando tú usas HashSet.remove() estás decidiendo qué juguete específico sacarás de la caja. Pero ojo, lo podrás sacar si el juguete está, de lo contrario no.

Sintaxis

public boolean remove(Object obj)

Parámetros

• obj: Recuerda que es el objeto que vas a eliminar del HashSet.

Valor de retorno

• true: Si el elemento fue eliminado con éxito.
• false: Si el elemento no estaba presente en el HashSet.

Cómo usar HashSet.remove() en Java: Ejemplos

Elimina elementos básicos

Primero haz algo sencillo, para que entiendas bien cómo funciona HashSet.remove() en Java:

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> frutas = new HashSet<>();

        frutas.add("Manzana");
        frutas.add("Pera");
        frutas.add("Mango");

        System.out.println("Frutas antes de eliminar: " + frutas);

        boolean eliminado = frutas.remove("Pera");
        System.out.println("Eliminado Pera: " + eliminado);

        System.out.println("Frutas después de eliminar: " + frutas);

        boolean noEliminado = frutas.remove("Fresa");
        System.out.println("Intento de eliminar Fresa: " + noEliminado);
    }
}

Mira la salida

Frutas antes de eliminar: [Manzana, Pera, Mango]
Eliminado Pera: true
Frutas después de eliminar: [Manzana, Mango]
Intento de eliminar Fresa: false

Trabajando con números

En este segundo ejemplo quiero mostrarte cómo usar un HashSet de números enteros. Es algo muy sencillo de hacer:

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);
        numeros.add(40);

        System.out.println("Números antes de eliminar: " + numeros);

        numeros.remove(20);
        System.out.println("Después de eliminar 20: " + numeros);

        boolean eliminado = numeros.remove(50);
        System.out.println("Intento de eliminar 50 (no existe): " + eliminado);
    }
}

Esta es la salida

Números antes de eliminar: [40, 10, 30, 20]
Después de eliminar 20: [40, 10, 30]
Intento de eliminar 50 (no existe): false

Uso con objetos personalizados

Algo que te recomiendo es que, al trabajar con objetos, te asegures de sobrescribir los métodos equals y hashCode para que el HashSet pueda identificar correctamente los elementos. Observa cómo sería:

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();
    }

    @Override
    public String toString() {
        return nombre;
    }
}

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

        personas.add(new Persona("Juan"));
        personas.add(new Persona("Ana"));
        personas.add(new Persona("Luis"));

        System.out.println("Personas antes de eliminar: " + personas);

        personas.remove(new Persona("Ana"));
        System.out.println("Personas después de eliminar Ana: " + personas);
    }
}

Esta es la salida

Personas antes de eliminar: [Juan, Ana, Luis]
Personas después de eliminar Ana: [Juan, Luis]

Consejos para usar adecuadamente HashSet.remove() en Java

• Sobrescribe equals y hashCode: Recuerda que, para objetos personalizados, es muy importante que sobrescribas estos métodos para evitar comportamientos inesperados.
• Evita modificar elementos mientras iteras: No olvides que si necesitas recorrer y eliminar elementos, lo mejor es usar un Iterator o la función removeIf de Stream.
• Verifica si el elemento existe: Lo bueno es que, cuando no estás seguro de si el elemento está presente, puedes combinar contains() con remove().

Creo que ya aprendiste que HashSet.remove() en Java gestiona muy bien tus colecciones de datos. Aprovecha estos ejemplos prácticos que te expliqué e impleméntalos en proyectos reales, así optimizarás el rendimiento de tu código y te parecerá más sencillo aprender a programar con Java.

¿Ya estás listo para darte la oportunidad de cambiar tu carrera y tu futuro? ¡Buenas noticias! En nuestro Bootcamp de Java Full Stack en KeepCoding, aprenderás a dominar estructuras de datos, desarrollo backend y más en tiempo récord. Todo en compañía de los mejores y más preparados profesionales ¡Apúntate ahora y da el salto a una carrera IT llena de oportunidades!