Java HashSet: valores únicos, pertencimento e operações de conjuntos

Um conjunto armazena valores únicos

Um HashSet (de java.util) é uma coleção que guarda cada valor no máximo uma vez. Não há chaves nem valores emparelhados como em um HashMap, apenas um saco de elementos distintos. Sua única função é responder rápido a uma pergunta: "isso está aqui 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");   // duplicata - ignorada

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

Há um único parâmetro de tipo, <ElementType>. Assim como com ArrayList e HashMap, normalmente você declara a variável com o tipo da interface Set e constrói um HashSet.

add retorna se o valor era novo

add não apenas armazena o valor: ele retorna um boolean informando se o conjunto realmente mudou. Adicionar um valor que já está presente retorna false e deixa o 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 novo
        System.out.println(seen.add(7));  // false - já estava lá
        System.out.println(seen);
    }
}

Esse valor de retorno é genuinamente útil: if (!seen.add(x)) { /* x é uma repetição */ } permite detectar duplicatas em uma única linha à medida que você avança.

Removendo duplicatas de uma lista

Como um conjunto rejeita repetições, a forma mais rápida de eliminar duplicatas de uma coleção é despejá-la em um. O construtor de HashSet aceita qualquer outra coleção:

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 nome uma vez
        System.out.println(unique.size());   // 3

        // precisa de uma List de volta?
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

Esse é o motivo mais comum pelo qual iniciantes recorrem a um conjunto. Só saiba que você perde a ordem original no caminho de ida e volta, use LinkedHashSet se a ordem importar (visto abaixo).

contains, remove e size

As operações do dia a dia espelham as das outras coleções:

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
    }
}

A grande vantagem sobre um ArrayList é o contains. Uma lista precisa percorrer todos os elementos para respondê-lo (O(n)); um HashSet chega quase direto à resposta (aproximadamente O(1)). Quando você se pegar chamando list.contains(...) dentro de um laço, esse costuma ser o sinal para mudar para um conjunto.

Operações de conjuntos: união, interseção, diferença

Os conjuntos se destacam quando você os combina. Os métodos se leem quase como linguagem natural quando você sabe qual é qual:

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);            // tudo que está em qualquer um dos conjuntos
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // só o que está em ambos
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // em a mas não em b
        System.out.println(difference);   // 1 2
    }
}

O detalhe crucial: addAll, retainAll e removeAll modificam o conjunto sobre o qual são chamados. É por isso que cada exemplo copia a para um HashSet novo primeiro, caso contrário você destruiria o original. Crie um conjunto novo para cada resultado.

HashSet não mantém a ordem

Assim como HashMap, um HashSet não promete nenhuma ordem de iteração, e a ordem pode variar entre execuções. Se você precisa de previsibilidade:

• LinkedHashSet preserva a ordem de inserção, a ordem em que você adicionou os elementos.
• TreeSet mantém os elementos ordenados pela ordem natural (ou por um Comparator que você fornecer).

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]
    }
}

Os três implementam a interface Set, então alternar entre eles é uma mudança de uma única linha no construtor.

Os elementos precisam ser hasheáveis

Um HashSet é apoiado internamente por um HashMap, então vale a mesma regra: ele localiza os elementos calculando o hash deles, o que significa que o hashCode() e o equals() de um elemento precisam ser consistentes. Tipos nativos como String e Integer já fazem isso corretamente, por isso as strings "java" duplicadas se fundem corretamente acima. Se você armazenar instâncias da sua própria classe, sobrescreva tanto equals quanto hashCode; caso contrário, dois objetos que são "iguais" em significado serão tratados como distintos, e contains e a eliminação de duplicatas falharão silenciosamente.

Próximo: Iterando coleções

Você já conheceu as três coleções fundamentais: ArrayList, HashMap e HashSet. Cada uma é percorrida de um jeito um pouco diferente, e há armadilhas sutis (como modificar uma coleção enquanto itera sobre ela). A seguir vamos juntar tudo e ver como iterar coleções de forma limpa com o laço for-each, os iteradores e o forEach.