Como Verificar se um Conjunto Contém um Elemento Específico em Java - Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se um elemento específico existe dentro de uma coleção em Java. Focaremos no uso do método contains(), que está disponível para todos os tipos de coleção. Você praticará o uso de contains() com diferentes tipos de elementos e aprenderá como lidar com elementos nulos. Ao final deste laboratório, você estará proficiente em determinar a presença de elementos dentro de coleções Java.

Usar contains() para Verificação de Elementos

Nesta etapa, exploraremos como verificar se um elemento específico existe dentro de uma coleção em Java. Coleções são estruturas de dados fundamentais usadas para agrupar múltiplos elementos em uma única unidade. Java fornece vários tipos de coleções, como Listas, Sets e Maps.

Uma tarefa comum ao trabalhar com coleções é determinar se um elemento particular está presente. A interface Collection do Java, que é a interface raiz para todos os tipos de coleção, fornece um método conveniente para este propósito: contains().

O método contains() recebe um argumento, o elemento que você deseja verificar, e retorna um valor booleano: true se o elemento for encontrado na coleção e false caso contrário.

Vamos criar um programa Java simples para demonstrar como usar o método contains() com um ArrayList, que é um tipo comum de List.

Abra o arquivo HelloJava.java no editor WebIDE, se ele ainda não estiver aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
import java.util.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List of strings
        List<String> fruits = new ArrayList<>();

        // Add some fruits to the list
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Mango");

        // Check if the list contains "Banana"
        boolean hasBanana = fruits.contains("Banana");
        System.out.println("Does the list contain Banana? " + hasBanana);

        // Check if the list contains "Grape"
        boolean hasGrape = fruits.contains("Grape");
        System.out.println("Does the list contain Grape? " + hasGrape);
    }
}
```
Vamos detalhar este novo código:
- import java.util.ArrayList; e import java.util.List;: Estas linhas importam as classes necessárias para trabalhar com Listas e ArrayLists.
- List<String> fruits = new ArrayList<>();: Esta linha cria um novo ArrayList que pode conter objetos String e o atribui a uma variável chamada fruits.
- fruits.add("Apple"); e linhas semelhantes: Estas linhas adicionam elementos (strings representando nomes de frutas) à nossa lista fruits.
- boolean hasBanana = fruits.contains("Banana");: Esta linha chama o método contains() na lista fruits, verificando se a string "Banana" está presente. O resultado (true ou false) é armazenado em uma variável booleana hasBanana.
- System.out.println("Does the list contain Banana? " + hasBanana);: Esta linha imprime o resultado da verificação para "Banana".
- boolean hasGrape = fruits.contains("Grape"); e o println seguinte: Estas linhas fazem a mesma verificação para "Grape", que não está na nossa lista.
Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
```
javac HelloJava.java
```

Execute o programa compilado:

java HelloJava

Você deve ver uma saída semelhante a esta:

Does the list contain Banana? true
Does the list contain Grape? false

Esta saída confirma que o método contains() identificou corretamente que "Banana" está na lista e "Grape" não está.

Compreender como verificar a presença de elementos é uma habilidade fundamental ao trabalhar com coleções em Java. Nas próximas etapas, exploraremos mais aspectos do método contains() e como ele se comporta em diferentes cenários.

Testar com Diferentes Tipos de Elementos

Na etapa anterior, usamos o método contains() com uma List de objetos String. O método contains() é versátil e pode ser usado com coleções que armazenam diferentes tipos de elementos, como números, objetos personalizados ou até mesmo outras coleções.

Ao usar contains(), Java se baseia no método equals() dos objetos dentro da coleção para determinar se o elemento que está sendo procurado corresponde. Para tipos primitivos (como int, double, boolean), suas classes wrapper correspondentes (Integer, Double, Boolean) são usadas, e seus métodos equals() comparam os valores. Para objetos, o método equals() padrão verifica se as duas referências de objeto apontam para o mesmo local de memória. No entanto, muitas classes (como String, Integer, etc.) substituem o método equals() para comparar o conteúdo real ou o valor dos objetos.

Vamos modificar nosso programa para trabalhar com uma List de objetos Integer e ver como contains() se comporta.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua o código atual pelo seguinte:

import java.util.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List of integers
        List<Integer> numbers = new ArrayList<>();

        // Add some numbers to the list
        numbers.add(10);
        numbers.add(25);
        numbers.add(5);
        numbers.add(50);

        // Check if the list contains 25
        boolean hasTwentyFive = numbers.contains(25);
        System.out.println("Does the list contain 25? " + hasTwentyFive);

        // Check if the list contains 100
        boolean hasOneHundred = numbers.contains(100);
        System.out.println("Does the list contain 100? " + hasOneHundred);

        // Check if the list contains the Integer object with value 5
        boolean hasFiveObject = numbers.contains(Integer.valueOf(5));
        System.out.println("Does the list contain Integer object with value 5? " + hasFiveObject);
    }
}

Neste código:

Criamos uma List que armazena especificamente objetos Integer: List<Integer> numbers = new ArrayList<>();.
Adicionamos valores inteiros à lista usando numbers.add(). Java converte automaticamente os valores primitivos int (10, 25, 5, 50) em objetos Integer (isso é chamado de autoboxing).
Usamos numbers.contains(25) e numbers.contains(100) para verificar a presença de valores inteiros. Novamente, Java faz autoboxing dos valores primitivos int 25 e 100 em objetos Integer antes de realizar a verificação.
Também criamos explicitamente um objeto Integer usando Integer.valueOf(5) e verificamos se a lista contém este objeto específico.

Salve o arquivo.
Compile o programa no Terminal:
```
javac HelloJava.java
```

Execute o programa:

java HelloJava

Você deve ver uma saída semelhante a esta:

Does the list contain 25? true
Does the list contain 100? false
Does the list contain Integer object with value 5? true

Isso demonstra que contains() funciona corretamente com objetos Integer, comparando seus valores. O método contains() usa efetivamente o método equals() dos elementos na coleção e do elemento que está sendo procurado.

Na próxima etapa, exploraremos um caso especial: lidar com elementos null com o método contains().

Lidar com Elementos Nulos

Em Java, coleções podem, às vezes, conter elementos null. É importante entender como o método contains() se comporta ao lidar com null.

A boa notícia é que o método contains() foi projetado para lidar com elementos null de forma elegante. Se uma coleção contiver null, chamar contains(null) retornará true. Se a coleção não contiver null, retornará false. Isso é consistente com a forma como equals() é geralmente implementado para null (o equals(null) de qualquer objeto deve retornar false, mas null.equals(anyObject) lançaria uma NullPointerException se não fosse tratado internamente pela implementação contains da coleção).

Vamos modificar nosso programa para incluir e verificar elementos null.

Abra o arquivo HelloJava.java no editor WebIDE.

Substitua o código atual pelo seguinte:

import java.util.ArrayList;
import java.util.List;

public class HelloJava {
    public static void main(String[] args) {
        // Create a List that can contain null
        List<String> mixedList = new ArrayList<>();

        // Add some elements, including null
        mixedList.add("First");
        mixedList.add(null); // Adding a null element
        mixedList.add("Second");
        mixedList.add(null); // Adding another null element
        mixedList.add("Third");

        // Check if the list contains null
        boolean hasNull = mixedList.contains(null);
        System.out.println("Does the list contain null? " + hasNull);

        // Check if the list contains a non-existent element
        boolean hasFourth = mixedList.contains("Fourth");
        System.out.println("Does the list contain Fourth? " + hasFourth);

        // Check if the list contains "First"
        boolean hasFirst = mixedList.contains("First");
        System.out.println("Does the list contain First? " + hasFirst);
    }
}

Neste código:

Criamos uma List chamada mixedList.
Adicionamos alguns elementos String e também adicionamos explicitamente null usando mixedList.add(null);.
Em seguida, usamos mixedList.contains(null) para verificar se a lista contém o valor null.
Também realizamos verificações para uma string inexistente ("Fourth") e uma string existente ("First") para ver os resultados junto com a verificação null.

Salve o arquivo.
Compile o programa no Terminal:
```
javac HelloJava.java
```

Execute o programa:

java HelloJava

Você deve ver uma saída semelhante a esta:

Does the list contain null? true
Does the list contain Fourth? false
Does the list contain First? true

Esta saída confirma que contains() identifica corretamente a presença de null dentro da lista. É importante estar ciente de que as coleções podem conter null (dependendo do tipo de coleção específico e de como ela é usada), e contains() fornece uma maneira confiável de verificar isso.

Você agora aprendeu como usar o método contains() para verificar elementos em coleções Java, incluindo diferentes tipos de dados e o caso especial de null. Esta é uma ferramenta valiosa para trabalhar com coleções em seus programas Java.

Resumo

Neste laboratório, aprendemos como verificar se uma coleção contém um elemento específico em Java usando o método contains(). Vimos como este método, disponível através da interface Collection, retorna um booleano indicando a presença do elemento. Demonstramos seu uso com um ArrayList e observamos como ele identifica corretamente elementos existentes e não existentes.

Também exploramos como o método contains() funciona com diferentes tipos de dados e como lidar com elementos nulos dentro de uma coleção. Essa experiência prática proporcionou uma compreensão prática de uma operação fundamental ao trabalhar com coleções Java.