LabEx
EntrarJunte-se

Como Verificar se um Conjunto Contém Todos os Elementos de Outro Conjunto em Java

JavaBeginner
Pratique Agora

Introdução

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.

Use containsAll() para Verificação de Subconjunto

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.java

Se 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 SubsetCheck

Você deverá ver uma saída semelhante a esta:

Main Set: [1, 2, 3, 4, 5]
Subset: [2, 4]
Is 'subset' a subset of 'mainSet'? true

Esta saída confirma que o método containsAll() identificou corretamente que subset é de fato um subconjunto de mainSet.

Teste com Diferentes Tipos de Conjuntos

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:

  • Importamos LinkedHashSet e TreeSet.
  • Criamos um hashMainSet usando HashSet.
  • Criamos 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.
  • Também adicionamos um 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.java

Se a compilação for bem-sucedida, execute o programa:

java SubsetCheck

Você 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? false

Isso 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.

Lidar com Conjuntos Vazios e Nulos

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:

  • Caso 1: Verificando com um conjunto vazio: Criamos um emptySet e verificamos se mainSet contém todos os seus elementos. Um conjunto vazio é considerado um subconjunto de qualquer conjunto, incluindo outro conjunto vazio.
  • Caso 2: Verificando se um conjunto vazio contém todos os elementos de um conjunto não vazio: Verificamos se anotherEmptySet contém todos os elementos de nonEmptySet. Isso deve ser falso porque o conjunto vazio não contém o elemento 1.
  • Caso 3: Verificando com um conjunto nulo: Definimos uma variável 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.java

Execute o programa compilado:

java SubsetCheck

Você 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.NullPointerException

Esta saída confirma o comportamento de containsAll() com conjuntos vazios e nulos:

  • Um conjunto vazio é sempre um subconjunto de outro conjunto (true).
  • Um conjunto não vazio nunca é um subconjunto de um conjunto vazio (false).
  • Passar null para containsAll() resulta em uma NullPointerException.

Compreender esses casos ajuda você a evitar possíveis erros ao trabalhar com conjuntos em Java.

Resumo

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.

Relacionados Java Cursos
Java para Iniciantes

Java para Iniciantes

java
Exercícios de Programação Java

Exercícios de Programação Java

java
Inserção em Massa de Dados na Grade de Cursos

Inserção em Massa de Dados na Grade de Cursos

java