C# Academy · Aula

HashSet e exclusividade

Acompanhe valores distintos.

HashSet e exclusividade é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que é um HashSet?

HashSet<T> armazena uma coleção de valores unique, sem duplicatas. Adicionar um valor que já está presente simplesmente não faz nada.

Assim como um dicionário, ele usa uma tabela de dispersão, portanto os testes de pertencimento têm custo O(1) em média. Ele não mantém a ordem de inserção.

using System.Collections.Generic;

var seen = new HashSet<int>();
seen.Add(1);
seen.Add(1); // ignored, still one element

Add retorna um booleano

Add retorna true se o valor era novo e false se já estava presente.

Esse valor de retorno é útil para detectar duplicatas em uma única etapa, sem uma verificação separada com Contains.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var set = new HashSet<string>();
        Console.WriteLine(set.Add("a")); // True
        Console.WriteLine(set.Add("a")); // False
    }
}

Testes rápidos de pertencimento

Contains em um HashSet tem custo O(1) em média, em comparação com O(n) em uma List.

Quando você pergunta repetidamente «já vi este valor?», um set é a ferramenta certa. A diferença de velocidade cresce drasticamente à medida que a coleção aumenta.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var ids = new HashSet<int> { 10, 20, 30 };
        Console.WriteLine(ids.Contains(20)); // True
        Console.WriteLine(ids.Contains(99)); // False
    }
}

Remover duplicatas de uma lista

Uma tarefa comum: receber uma lista e manter apenas valores distintos. Construir um HashSet a partir da lista faz isso em O(n).

O set resultante contém cada valor uma vez. Se precisar de uma lista novamente, envolva-o: new List<int>(set).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 1, 2, 2, 3, 3, 3 };
        var unique = new HashSet<int>(nums);
        Console.WriteLine(unique.Count); // 3
    }
}

União

UnionWith adiciona todos os elementos de outra coleção, ignorando duplicatas. O resultado contém tudo das duas.

Isso modifica o set diretamente. É muito mais limpo do que percorrer a coleção e chamar Add para cada item por conta própria.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var a = new HashSet<int> { 1, 2, 3 };
        a.UnionWith(new[] { 3, 4, 5 });
        Console.WriteLine(a.Count); // 5
    }
}

Interseção

IntersectWith mantém apenas os elementos que também aparecem na outra coleção, descartando os demais.

Use-o para encontrar itens comuns, como tags compartilhadas por dois artigos ou users presentes em ambos os groups.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var a = new HashSet<int> { 1, 2, 3, 4 };
        a.IntersectWith(new[] { 2, 4, 6 });
        Console.WriteLine(string.Join(",", a)); // 2,4
    }
}

Diferença

ExceptWith remove do set qualquer elemento encontrado na outra coleção, deixando o que é exclusivo do set.

É a operação set menos: «itens em A, mas não em B». É excelente para calcular o que mudou ou o que ainda falta processar.

var a = new HashSet<int> { 1, 2, 3, 4 };
a.ExceptWith(new[] { 2, 4 });
// a now contains 1 and 3

Subconjunto e superconjunto

IsSubsetOf e IsSupersetOf testam relações de contenção entre conjuntos, retornando um bool.

Overlaps verifica se algum elemento é compartilhado, e SetEquals testa se dois conjuntos contêm exatamente os mesmos elementos, independentemente da ordem.

var a = new HashSet<int> { 1, 2 };
var b = new HashSet<int> { 1, 2, 3 };
bool sub = a.IsSubsetOf(b);   // true
bool ov = a.Overlaps(b);      // true

Igualdade dos elementos

A exclusividade depende de GetHashCode e Equals do tipo do elemento, exatamente como ocorre com as chaves de um dicionário.

Para tipos personalizados, substitua ambos ou use um record; caso contrário, dois objetos logicamente iguais serão tratados como distintos e ambos acabarão no conjunto.

var names = new HashSet<string>(
    System.StringComparer.OrdinalIgnoreCase);
names.Add("Sam");
bool dup = !names.Add("SAM"); // true: treated as same

Sem indexação nem ordem

Um HashSet não oferece acesso por índice; você não pode escrever set[0]. Só pode enumerá-lo com foreach.

A ordem de enumeração não é garantida. Se precisar de exclusividade e ordem sorted, use SortedSet<T>, que mantém os elementos ordenados ao custo de operações O(log n).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var s = new SortedSet<int> { 3, 1, 2 };
        Console.WriteLine(string.Join(",", s)); // 1,2,3
    }
}

Rastrear itens vistos

Um padrão frequente é filtrar um fluxo para que cada valor apareça uma vez. Adicione o valor a um conjunto e aja somente quando Add retornar true.

Isso é mais limpo e rápido do que verificar uma lista crescente, transformando uma varredura O(n ao quadrado) em O(n).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var seen = new HashSet<int>();
        foreach (int x in new[] { 1, 1, 2, 3, 2 })
            if (seen.Add(x)) Console.Write(x + " ");
        // prints 1 2 3
    }
}

Verificação rápida

Lembre-se do que um HashSet garante e do custo de suas pesquisas.

Recapitulação

HashSet<T> armazena valores unique e oferece adição, remoção e testes de pertencimento em O(1) em média, mas não oferece ordem nem indexação.

Ele é excelente para remover duplicatas, fazer verificações rápidas de «já vi isto» e realizar álgebra de set por meio de UnionWith, IntersectWith e ExceptWith. Tipos personalizados de elementos precisam implementar uma igualdade adequada.

Perguntas Frequentes

A aula “HashSet e exclusividade” é grátis?

Sim — o texto completo de “HashSet e exclusividade” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “HashSet e exclusividade”?

Acompanhe valores distintos. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “HashSet e exclusividade”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy