Java HashSet: valores únicos, pertenencia y operaciones de conjuntos

Un conjunto almacena valores únicos

Un HashSet (de java.util) es una colección que guarda cada valor como máximo una vez. No hay claves ni valores emparejados como en un HashMap, solo un saco de elementos distintos. Su único cometido es responder rápido a una pregunta: "¿está esto aquí dentro?"

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("java");   // duplicado - se ignora

        System.out.println(tags.contains("java"));     // true
        System.out.println(tags.contains("frontend")); // false
        System.out.println(tags.size());               // 2
    }
}

Hay un único parámetro de tipo, <ElementType>. Igual que con ArrayList y HashMap, normalmente declaras la variable con el tipo de la interfaz Set y construyes un HashSet.

add devuelve si el valor era nuevo

add no solo almacena el valor: devuelve un boolean que te indica si el conjunto cambió realmente. Añadir un valor que ya está presente devuelve false y deja el conjunto intacto.

import java.util.HashSet;
import java.util.Set;

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

        System.out.println(seen.add(7));  // true  - 7 era nuevo
        System.out.println(seen.add(7));  // false - ya estaba
        System.out.println(seen);
    }
}

Ese valor de retorno es realmente útil: if (!seen.add(x)) { /* x es un repetido */ } te permite detectar duplicados en una sola línea sobre la marcha.

Eliminar duplicados de una lista

Como un conjunto rechaza los repetidos, la forma más rápida de quitar duplicados de una colección es volcarla en uno. El constructor de HashSet acepta cualquier otra colección:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Ada", "Boris", "Ada", "Chen", "Boris"));

        Set<String> unique = new HashSet<>(names);
        System.out.println(unique);          // cada nombre una vez
        System.out.println(unique.size());   // 3

        // ¿necesitas recuperar una List?
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

Esta es la razón más común por la que los principiantes recurren a un conjunto. Solo ten en cuenta que pierdes el orden original en la ida y vuelta: usa LinkedHashSet si el orden importa (lo vemos más abajo).

contains, remove y size

Las operaciones del día a día reflejan las de las otras colecciones:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("api");

        System.out.println(tags.contains("api"));  // true
        System.out.println(tags.size());           // 3

        tags.remove("backend");
        System.out.println(tags.contains("backend")); // false

        tags.clear();
        System.out.println(tags.isEmpty());         // true
    }
}

La gran ventaja sobre un ArrayList es contains. Una lista tiene que recorrer todos los elementos para responder (O(n)); un HashSet llega casi directamente a la respuesta (aproximadamente O(1)). Cuando te descubras llamando a list.contains(...) dentro de un bucle, esa suele ser la señal para cambiar a un conjunto.

Operaciones de conjuntos: unión, intersección, diferencia

Los conjuntos brillan cuando los combinas. Los métodos se leen casi como lenguaje natural una vez que sabes cuál es cuál:

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> a = new HashSet<>(Set.of(1, 2, 3, 4));
        Set<Integer> b = new HashSet<>(Set.of(3, 4, 5, 6));

        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);            // todo lo que está en cualquiera de los dos
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // solo lo que está en ambos
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // en a pero no en b
        System.out.println(difference);   // 1 2
    }
}

El detalle clave: addAll, retainAll y removeAll modifican el conjunto sobre el que se llaman. Por eso cada ejemplo copia a en un HashSet nuevo primero; de lo contrario destruirías tu original. Crea un conjunto nuevo para cada resultado.

HashSet no mantiene el orden

Igual que HashMap, un HashSet no garantiza ningún orden de iteración, y el orden puede variar entre ejecuciones. Si necesitas previsibilidad:

• LinkedHashSet conserva el orden de inserción, el orden en que añadiste los elementos.
• TreeSet mantiene los elementos ordenados por su orden natural (o por un Comparator que tú proporciones).

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Set<String> insertion = new LinkedHashSet<>();
        insertion.add("gamma");
        insertion.add("alpha");
        insertion.add("beta");
        System.out.println(insertion);  // [gamma, alpha, beta]

        Set<String> sorted = new TreeSet<>(insertion);
        System.out.println(sorted);      // [alpha, beta, gamma]
    }
}

Los tres implementan la interfaz Set, así que cambiar entre ellos es una modificación de una sola línea en el constructor.

Los elementos deben ser hashables

Un HashSet está respaldado internamente por un HashMap, así que se aplica la misma regla: localiza los elementos calculando su hash, lo que significa que el hashCode() y el equals() de un elemento deben ser coherentes. Los tipos integrados como String e Integer ya lo hacen bien, por eso las cadenas "java" duplicadas se fusionan correctamente arriba. Si almacenas instancias de tu propia clase, sobrescribe tanto equals como hashCode; de lo contrario, dos objetos que son "iguales" en significado se tratarán como distintos, y contains y la eliminación de duplicados fallarán en silencio.

Siguiente: Iterar colecciones

Ya has conocido las tres colecciones fundamentales: ArrayList, HashMap y HashSet. Cada una se recorre de forma un poco distinta, y hay trampas sutiles (como modificar una colección mientras iteras sobre ella). A continuación lo juntaremos todo y veremos cómo iterar colecciones de forma limpia con el bucle for-each, los iteradores y forEach.