Como Verificar se uma Lista Contém um Elemento Específico em Java

Introdução

Neste laboratório, você aprenderá como verificar se um elemento específico existe dentro de uma List Java. Exploraremos diferentes métodos para realizar esta tarefa comum ao trabalhar com coleções de dados.

Primeiramente, você aprenderá a usar o método contains() conveniente fornecido pela interface List. Em seguida, você entenderá como iterar manualmente por uma lista para verificar um elemento, o que pode ser útil em certos cenários. Por fim, abordaremos como lidar com a presença de elementos nulos dentro de sua lista ao realizar essas verificações.

Usar contains() para Verificação de Elementos

Nesta etapa, aprenderemos como verificar se um elemento específico existe em uma List Java usando o método contains(). Esta é uma tarefa comum ao trabalhar com coleções de dados.

Primeiro, vamos criar um novo arquivo Java chamado ListContains.java em seu diretório ~/project. Você pode fazer isso clicando com o botão direito no File Explorer à esquerda e selecionando "New File" (Novo Arquivo), em seguida, digitando ListContains.java.

Agora, abra o arquivo ListContains.java no editor e adicione o seguinte código:

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

public class ListContains {

    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 analisar este código:

• import java.util.ArrayList; e import java.util.List;: Estas linhas importam as classes necessárias para trabalhar com Listas.
• List<String> fruits = new ArrayList<>();: Esta linha cria um novo ArrayList, que é um tipo de List que pode conter objetos String.
• fruits.add("...");: Estas linhas adicionam elementos (nomes de frutas) à nossa lista.
• fruits.contains("Banana");: Este é o núcleo desta etapa. O método contains() é chamado na lista fruits. Ele recebe um argumento, o elemento que queremos verificar. Ele retorna true se o elemento for encontrado na lista e false caso contrário.
• boolean hasBanana = ...;: O resultado de contains() é armazenado em uma variável booleana (hasBanana ou hasGrape).
• System.out.println("...");: Estas linhas imprimem os resultados no console.

Salve o arquivo ListContains.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, digite cd ~/project e pressione Enter.

Compile o código Java usando o comando javac:

javac ListContains.java

Se não houver erros, um arquivo ListContains.class será criado no diretório ~/project.

Finalmente, execute o programa Java compilado usando o comando java:

java ListContains

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 se "Banana" e "Grape" estavam presentes em nossa lista.

Iterar Manualmente pela Lista

Na etapa anterior, usamos o método contains() para verificar um elemento. Embora contains() seja conveniente, às vezes é necessário examinar cada elemento em uma lista um por um. Isso é chamado de iterar ou percorrer uma lista. Nesta etapa, aprenderemos como fazer isso usando um loop for.

Abra o arquivo ListContains.java em seu diretório ~/project no editor WebIDE.

Modificaremos o código existente para percorrer a lista fruits e imprimir cada elemento. Substitua o método main existente pelo seguinte código:

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

public class ListContains {

    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");

        // Loop through the list using a for loop
        System.out.println("Printing fruits in the list:");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);
            System.out.println(fruit);
        }
    }
}

Vamos analisar as novas partes:

• System.out.println("Printing fruits in the list:");: Esta linha simplesmente imprime um cabeçalho antes de começarmos a listar as frutas.
• for (int i = 0; i < fruits.size(); i++): Este é um loop for padrão.
  • int i = 0: Iniciamos uma variável contadora i em 0. Em programação, geralmente começamos a contar de 0.
  • i < fruits.size(): O loop continua enquanto i for menor que o número total de elementos na lista fruits. fruits.size() nos dá o número de elementos.
  • i++: Após cada execução do loop, aumentamos o valor de i em 1.
• String fruit = fruits.get(i);: Dentro do loop, fruits.get(i) recupera o elemento na posição atual i da lista. Armazenamos este elemento em uma variável String chamada fruit.
• System.out.println(fruit);: Esta linha imprime a fruit atual no console.

Salve o arquivo ListContains.java.

Agora, compile o código modificado no Terminal:

javac ListContains.java

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

java ListContains

Você deve ver a seguinte saída:

Printing fruits in the list:
Apple
Banana
Orange
Mango

Isso mostra que nosso loop for iterou com sucesso pela lista e imprimiu cada fruta em uma nova linha. Percorrer manualmente uma lista como esta oferece mais controle sobre como você processa cada elemento, o que pode ser útil para tarefas mais complexas do que apenas verificar a existência.

Lidar com Elementos Nulos na Lista

No mundo real, as listas podem, às vezes, conter valores "null", que representam a ausência de um valor. Se você tentar realizar operações em um valor nulo sem verificar, seu programa pode travar com uma NullPointerException. Nesta etapa, aprenderemos como lidar com elementos nulos ao percorrer uma lista.

Abra o arquivo ListContains.java em seu diretório ~/project no editor WebIDE.

Modificaremos o código para adicionar um elemento null à lista e, em seguida, verificar se há nulos dentro do loop. Substitua o método main existente pelo seguinte código:

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

public class ListContains {

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

        // Add some fruits to the list, including a null
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add(null); // Adding a null element
        fruits.add("Orange");
        fruits.add("Mango");

        // Loop through the list and handle null elements
        System.out.println("Printing fruits in the list (handling nulls):");
        for (int i = 0; i < fruits.size(); i++) {
            String fruit = fruits.get(i);

            // Check if the element is null before processing
            if (fruit != null) {
                System.out.println(fruit);
            } else {
                System.out.println("Found a null element");
            }
        }
    }
}

Aqui está o que mudamos:

• fruits.add(null);: Adicionamos um valor null à lista.
• if (fruit != null): Dentro do loop, antes de tentar imprimir a fruit, adicionamos uma instrução if para verificar se a variável fruit não é nula.
• System.out.println(fruit);: Esta linha está dentro do bloco if, portanto, ela só será executada se fruit não for nula.
• else { System.out.println("Found a null element"); }: Este bloco else é executado se fruit for nula, imprimindo uma mensagem em vez de tentar imprimir o próprio valor nulo.

Salve o arquivo ListContains.java.

Compile o código modificado no Terminal:

javac ListContains.java

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

java ListContains

Você deve ver a seguinte saída:

Printing fruits in the list (handling nulls):
Apple
Banana
Found a null element
Orange
Mango

Como você pode ver, o programa agora identifica e lida corretamente com o elemento nulo sem travar. Verificar se há nulos é uma prática crucial na programação Java para evitar erros e tornar seus programas mais robustos.

Resumo

Neste laboratório, aprendemos como verificar se uma List Java contém um elemento específico. Primeiro, exploramos o método mais direto, usando o método contains() integrado, que determina eficientemente a presença de um elemento e retorna um resultado booleano.

Em seguida, mergulhamos na iteração manual pela lista para realizar a verificação, proporcionando uma compreensão mais profunda de como o método contains() pode funcionar internamente. Por fim, abordamos a importante consideração de lidar com elementos nulos dentro da lista ao realizar essas verificações, garantindo um código robusto e livre de erros.