Um conjunto é simplesmente uma coleção de objetos únicos. Único significa que dois objetos não podem ter o(s) mesmo(s) valor(es). Dependendo da implementação do conjunto, pode ou não ser encomendado. O conjunto Java, como um tipo abstrato de dados (ADT), possui algumas operações importantes (onde T representa qualquer tipo de dados, por exemplo, int, String ou qualquer objeto de classe):

boolean add(T item)
: retorna verdadeiro se o item for adicionado com sucesso ao conjunto e falso se o item já estiver no conjunto.boolean remove(T item)
: retorna verdadeiro se o item foi removido do conjunto com sucesso e falso caso contrário (se o item não estava no conjunto).boolean contains(T item)
: retorna verdadeiro se o item estiver no conjunto e falso caso contrário.boolean isEmpty()
: retorna verdadeiro se o conjunto estiver vazio e falso caso contrário.
contains()
função fornece um ótimo tempo de execução para isso: complexidade de tempo O(1) ou O(log n) dependendo se a implementação usada é a HashSet
ou aTreeSet
, respectivamente. Então, para que um conjunto pode ser usado? Bem, se você precisar acompanhar muitos objetos distintos - como IDs, nomes ou outros identificadores exclusivos - e verificar com frequência se existe um item em tal coleção, um conjunto provavelmente será uma boa escolha. Aqui está um exemplo de caso de uso de um conjunto: Imagine que você tem uma lista de Student
objetos que representam todos os alunos de uma determinada turma. Cada um Student
pode ter um nome exclusivo (string) e nota (int) para esta classe. Se você quiser fazer referência a uma lista de todos os alunos A (nota >=90) com frequência, seria tedioso percorrer essa lista e verificar a nota de cada aluno todas as vezes. Em vez disso, você pode usar um HashSet
of strings que rastreia todos os alunos A da turma, da seguinte forma:
- Sempre que as notas dos alunos forem atualizadas, basta verificar se a nova nota do aluno é maior ou igual a 90 ou não.
- Em caso afirmativo, adicione-os ao conjunto de alunos A usando
add()
- Se eles já eram alunos A, essa operação é simplesmente ignorada.
- Caso contrário, remova-os do conjunto de alunos A usando
remove()
- Se eles não forem um aluno A neste ponto, essa operação será simplesmente ignorada.
- Em caso afirmativo, adicione-os ao conjunto de alunos A usando
contains(“Johnny Appleseed”)
para o aparelho. Claro, este é apenas um exemplo de caso de uso para um conjunto, e este problema específico de acompanhar os alunos A poderia ser resolvido de outras maneiras.
Implementações: HashSet em Java e Java TreeSet Exemplos
Tanto oHashSet
in Java quanto o TreeSet
in Java vêm no formato java.utils package
. Você pode importá-los como tal:
// imports everything from Java's util package, including HashSet and TreeSet
import java.util.*;
ou
import java.util.HashSet; // imports only the Java HashSet
import java.util.TreeSet; // imports only the Java TreeSet
A principal diferença entre o Java HashSet
e o Java TreeSet
é que o TreeSet
é classificado, enquanto o HashSet
não é. É por isso que TreeSet
tem complexidade de tempo O(log n) para operações de chave, enquanto HashSet
tem complexidade de tempo O(1) ou constante; o TreeSet
deve manter a ordem em todos os momentos. Além das operações de conjunto de chaves mencionadas anteriormente, tanto o HashSet
quanto TreeSet
em Java têm algumas outras funções úteis:
void clear()
: limpa o conjunto de todos os objetos.int size()
: retorna o número de objetos no conjunto.Object clone()
: retorna uma cópia rasa do conjunto.Iterator iterator()
: retorna um iterador para o conjunto, começando no primeiro objeto.
size()
se quisesse ver quantos alunos 'A' você tinha ou clear()
se quisesse limpar a lista no final do semestre. Você pode usar clone()
para criar e manter um clone da lista de alunos A em um ponto específico no tempo, como durante os relatórios intermediários (desta forma, o clone não fica atualizado junto com o original).
Exemplo de Java HashSet
Aqui está um pequeno exemplo de umHashSet
of String
s sendo usado em Java:
import java.util.HashSet;
class HashSetDemo {
public static void main(String[] args)
{
// create a HashSet of Strings
HashSet<String> hs = new HashSet<String>();
// Add elements using the add() method
hs.add("Collin");
hs.add("Bob");
hs.add("Abigail");
// Duplicates will ignored; this statement is useless
hs.add("Collin");
System.out.println(hs);
System.out.println("Bob is in the set (T/F): " + hs.contains("Bob"));
System.out.println("Max is in the set (T/F): " + hs.contains("Max"));
}
}
Saída: --------
[Collin, Bob, Abigail]
Bob is in the set (T/F): true
Max is in the set (T/F): false
Exemplo de Java TreeSet
O exemplo de conjunto Java pode ajudá-lo a entender a teoria. Aqui está um pequeno exemplo de umTreeSet
of String
s sendo usado em Java:
import java.util.TreeSet;
class TreeSetDemo {
public static void main(String[] args)
{
// create a TreeSet of Strings
TreeSet<String> ts = new TreeSet<String>();
// Add elements using the add() method.
ts.add("Collin");
ts.add("Bob");
ts.add("Abigail");
// Duplicates will ignored; this statement is useless
ts.add("Collin");
// printing the set prints the names in alphabetical order!
System.out.println(ts);
System.out.println("Bob is in the set (T/F): " + ts.contains("Bob"));
System.out.println("Max is in the set (T/F): " + ts.contains("Max"));
System.out.println("Size of the set: " + ts.size());
ts.clear();
System.out.println("Size of the set after clear(): " + ts.size());
}
}
Saída: -------
[Abigail, Bob, Collin]
Bob is in the set (T/F): true
Max is in the set (T/F): false
Size of the set: 3
Size of the set after clear(): 0
Isso é tudo! Espero ter ajudado 😊
GO TO FULL VERSION