Neste laboratório, você aprenderá como verificar se um conjunto contém todos os elementos de outro conjunto em Java. Exploraremos o método containsAll(), uma maneira conveniente de realizar essa verificação de subconjunto.
Através de exemplos práticos, você aprenderá como usar containsAll() com diferentes tipos de conjuntos e como lidar com casos extremos (edge cases) como conjuntos vazios e nulos.
Nesta etapa, exploraremos como verificar se um conjunto é um subconjunto de outro usando o método containsAll() em Java. Esta é uma operação comum ao trabalhar com coleções, e containsAll() fornece uma maneira conveniente de realizar essa verificação.
Primeiro, vamos criar um novo arquivo Java chamado SubsetCheck.java no seu diretório ~/project. Você pode fazer isso clicando com o botão direito no File Explorer à esquerda e selecionando "New File", em seguida, digitando SubsetCheck.java.
Agora, abra o arquivo SubsetCheck.java no editor e adicione o seguinte código:
import java.util.HashSet;
import java.util.Set;
public class SubsetCheck {
public static void main(String[] args) {
// Create the main set
Set<Integer> mainSet = new HashSet<>();
mainSet.add(1);
mainSet.add(2);
mainSet.add(3);
mainSet.add(4);
mainSet.add(5);
// Create a potential subset
Set<Integer> subset = new HashSet<>();
subset.add(2);
subset.add(4);
// Check if 'subset' is a subset of 'mainSet'
boolean isSubset = mainSet.containsAll(subset);
// Print the result
System.out.println("Main Set: " + mainSet);
System.out.println("Subset: " + subset);
System.out.println("Is 'subset' a subset of 'mainSet'? " + isSubset);
}
}Vamos analisar o código:
import java.util.HashSet; e import java.util.Set;: Estas linhas importam as classes necessárias para trabalhar com conjuntos.Set<Integer> mainSet = new HashSet<>();: Isso cria um HashSet chamado mainSet que armazenará valores inteiros.mainSet.add(...): Estas linhas adicionam elementos ao mainSet.Set<Integer> subset = new HashSet<>();: Isso cria outro HashSet chamado subset.subset.add(...): Estas linhas adicionam elementos ao subset.boolean isSubset = mainSet.containsAll(subset);: Este é o núcleo desta etapa. O método containsAll() do mainSet é chamado com subset como argumento. Ele retorna true se mainSet contém todos os elementos de subset, e false caso contrário.System.out.println(...): Estas linhas imprimem os conjuntos e o resultado da verificação de subconjunto no console.Salve o arquivo SubsetCheck.java (Ctrl+S ou Cmd+S).
Agora, abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project. Caso contrário, use o comando cd ~/project.
Compile o código Java usando o comando javac:
javac SubsetCheck.javaSe não houver erros, você não deverá ver nenhuma saída. Isso significa que a compilação foi bem-sucedida e um arquivo SubsetCheck.class foi criado.
Finalmente, execute o programa Java compilado usando o comando java:
java SubsetCheckVocê deverá ver uma saída semelhante a esta:
Main Set: [1, 2, 3, 4, 5]
Subset: [2, 4]
Is 'subset' a subset of 'mainSet'? trueEsta saída confirma que o método containsAll() identificou corretamente que subset é de fato um subconjunto de mainSet.
Na etapa anterior, usamos HashSet para demonstrar o método containsAll(). Java fornece diferentes implementações da interface Set, como HashSet, LinkedHashSet e TreeSet. Embora tenham diferentes estruturas internas e propriedades (como ordem), o método containsAll() funciona consistentemente em todas elas.
Nesta etapa, modificaremos nosso arquivo SubsetCheck.java para testar containsAll() com diferentes tipos de conjuntos.
Abra o arquivo SubsetCheck.java no editor WebIDE.
Substitua o código existente pelo seguinte:
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class SubsetCheck {
public static void main(String[] args) {
// Create a main set using HashSet
Set<Integer> hashMainSet = new HashSet<>();
hashMainSet.add(10);
hashMainSet.add(20);
hashMainSet.add(30);
hashMainSet.add(40);
// Create a subset using LinkedHashSet
Set<Integer> linkedSubset = new LinkedHashSet<>();
linkedSubset.add(30);
linkedSubset.add(10);
// Create another subset using TreeSet
Set<Integer> treeSubset = new TreeSet<>();
treeSubset.add(40);
treeSubset.add(20);
// Check subset relationship using containsAll()
boolean isLinkedSubset = hashMainSet.containsAll(linkedSubset);
boolean isTreeSubset = hashMainSet.containsAll(treeSubset);
// Create a subset that is NOT a subset
Set<Integer> notSubset = new HashSet<>();
notSubset.add(20);
notSubset.add(50); // 50 is not in hashMainSet
boolean isNotSubset = hashMainSet.containsAll(notSubset);
// Print the results
System.out.println("Hash Main Set: " + hashMainSet);
System.out.println("Linked Subset: " + linkedSubset);
System.out.println("Is Linked Subset a subset of Hash Main Set? " + isLinkedSubset);
System.out.println("Tree Subset: " + treeSubset);
System.out.println("Is Tree Subset a subset of Hash Main Set? " + isTreeSubset);
System.out.println("Not Subset: " + notSubset);
System.out.println("Is Not Subset a subset of Hash Main Set? " + isNotSubset);
}
}Neste código atualizado:
LinkedHashSet e TreeSet.hashMainSet usando HashSet.linkedSubset usando LinkedHashSet e treeSubset usando TreeSet. Observe que a ordem dos elementos adicionados a linkedSubset é diferente de como eles aparecem em hashMainSet, mas containsAll() ainda funciona corretamente. TreeSet classifica automaticamente os elementos.notSubset para demonstrar um caso em que containsAll() retorna false.Salve o arquivo SubsetCheck.java.
Agora, compile o código modificado no Terminal:
javac SubsetCheck.javaSe a compilação for bem-sucedida, execute o programa:
java SubsetCheckVocê deverá ver uma saída semelhante a esta:
Hash Main Set: [40, 10, 20, 30]
Linked Subset: [30, 10]
Is Linked Subset a subset of Hash Main Set? true
Tree Subset: [20, 40]
Is Tree Subset a subset of Hash Main Set? true
Not Subset: [50, 20]
Is Not Subset a subset of Hash Main Set? falseIsso demonstra que containsAll() funciona corretamente, independentemente da implementação específica de Set usada para o subconjunto, desde que o conjunto principal contenha todos os elementos do subconjunto.
Nesta etapa final, examinaremos como o método containsAll() se comporta ao lidar com conjuntos vazios e valores nulos. Compreender esses casos extremos é importante para escrever um código robusto.
Abra o arquivo SubsetCheck.java no editor WebIDE.
Substitua o código existente pelo seguinte:
import java.util.HashSet;
import java.util.Set;
public class SubsetCheck {
public static void main(String[] args) {
Set<Integer> mainSet = new HashSet<>();
mainSet.add(1);
mainSet.add(2);
mainSet.add(3);
// Case 1: Checking with an empty set
Set<Integer> emptySet = new HashSet<>();
boolean isEmptySubset = mainSet.containsAll(emptySet);
System.out.println("Main Set: " + mainSet);
System.out.println("Empty Set: " + emptySet);
System.out.println("Is Empty Set a subset of Main Set? " + isEmptySubset);
System.out.println("---"); // Separator
// Case 2: Checking if an empty set contains all elements of a non-empty set
Set<Integer> anotherEmptySet = new HashSet<>();
Set<Integer> nonEmptySet = new HashSet<>();
nonEmptySet.add(1);
boolean isEmptyContainingNonEmpty = anotherEmptySet.containsAll(nonEmptySet);
System.out.println("Another Empty Set: " + anotherEmptySet);
System.out.println("Non-Empty Set: " + nonEmptySet);
System.out.println("Is Another Empty Set a subset of Non-Empty Set? " + isEmptyContainingNonEmpty);
System.out.println("---"); // Separator
// Case 3: Checking with a null set
Set<Integer> nullSet = null;
try {
boolean isNullSubset = mainSet.containsAll(nullSet);
System.out.println("Is Null Set a subset of Main Set? " + isNullSubset);
} catch (NullPointerException e) {
System.out.println("Checking with a null set resulted in a: " + e.getClass().getName());
}
}
}Vamos analisar as novas partes:
emptySet e verificamos se mainSet contém todos os seus elementos. Um conjunto vazio é considerado um subconjunto de qualquer conjunto, incluindo outro conjunto vazio.anotherEmptySet contém todos os elementos de nonEmptySet. Isso deve ser falso porque o conjunto vazio não contém o elemento 1.Set como null. Tentar chamar containsAll() com um argumento null resultará em uma NullPointerException. Usamos um bloco try-catch para lidar com essa exceção esperada de forma adequada e imprimir uma mensagem.Salve o arquivo SubsetCheck.java.
Compile o código no Terminal:
javac SubsetCheck.javaExecute o programa compilado:
java SubsetCheckVocê deverá ver uma saída semelhante a esta:
Main Set: [1, 2, 3]
Empty Set: []
Is Empty Set a subset of Main Set? true
---
Another Empty Set: []
Non-Empty Set: [1]
Is Another Empty Set a subset of Non-Empty Set? false
---
Checking with a null set resulted in a: java.lang.NullPointerExceptionEsta saída confirma o comportamento de containsAll() com conjuntos vazios e nulos:
true).false).null para containsAll() resulta em uma NullPointerException.Compreender esses casos ajuda você a evitar possíveis erros ao trabalhar com conjuntos em Java.
Neste laboratório, aprendemos como verificar se um conjunto contém todos os elementos de outro conjunto em Java usando o método containsAll(). Começamos criando um exemplo básico usando HashSet para demonstrar a funcionalidade principal de containsAll(). Este método fornece uma maneira direta de determinar se um potencial subconjunto está realmente contido dentro de um conjunto maior.
Em seguida, exploramos como testar essa funcionalidade com diferentes tipos de conjuntos, entendendo que containsAll() funciona consistentemente em várias implementações de Set. Finalmente, abordamos as considerações importantes de lidar com conjuntos vazios e nulos ao realizar verificações de subconjuntos, garantindo um código robusto e livre de erros.
