Como Verificar se um Array Contém um Elemento Específico em Java - Guia Completo

Introdução

Neste laboratório, você aprenderá como verificar se um elemento específico existe dentro de um array Java usando diferentes técnicas. Começaremos explorando a abordagem fundamental de iterar pelo array usando um loop for tradicional para procurar o elemento.

Após o método de iteração básico, você descobrirá como aproveitar o método Arrays.stream() para uma maneira mais concisa e potencialmente mais eficiente de verificar a presença do elemento. Finalmente, abordaremos a importante consideração de lidar com elementos nulos dentro do array durante suas operações de busca.

Iterar pelo Array para Encontrar o Elemento

Nesta etapa, você aprenderá como verificar se um elemento específico existe dentro de um array Java, iterando por ele usando um loop for tradicional. Esta é uma técnica fundamental para pesquisar dentro de coleções de dados.

Primeiro, vamos criar um novo arquivo Java chamado ArraySearch.java no seu diretório ~/project. Você pode fazer isso usando o explorador de arquivos WebIDE à esquerda ou executando o seguinte comando no terminal:

touch ~/project/ArraySearch.java

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

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Variable to keep track if the element is found
        boolean found = false;

        // Loop through the array
        for (int i = 0; i < fruits.length; i++) {
            // Check if the current element is equal to the search element
            if (fruits[i].equals(searchElement)) {
                found = true; // Element found
                break; // Exit the loop since we found the element
            }
        }

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }
    }
}

Vamos detalhar este código:

String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};: Esta linha declara e inicializa um array de strings chamado fruits com vários nomes de frutas.
String searchElement = "Cherry";: Esta linha declara uma variável de string searchElement e atribui o valor "Cherry" a ela. Este é o elemento que estamos procurando no array.
boolean found = false;: Esta linha declara uma variável booleana found e a inicializa como false. Definiremos isso como true se encontrarmos o searchElement no array.
for (int i = 0; i < fruits.length; i++): Este é um loop for padrão que itera pelo array. i começa em 0 e vai até (mas não incluindo) o comprimento do array fruits.
if (fruits[i].equals(searchElement)): Dentro do loop, esta instrução if verifica se o elemento atual do array (fruits[i]) é igual ao searchElement. Usamos o método .equals() para comparar strings em Java, não o operador ==.
found = true;: Se os elementos forem iguais, definimos a variável found como true.
break;: Uma vez que o elemento é encontrado, usamos a instrução break para sair do loop antecipadamente, pois não há necessidade de continuar a busca.
O bloco if/else final imprime uma mensagem indicando se o searchElement foi encontrado com base no valor da variável found.

Salve o arquivo ArraySearch.java (Ctrl+S ou Cmd+S).

Agora, vamos compilar e executar o programa no terminal. Certifique-se de estar no diretório ~/project.

Compile o código:

javac ArraySearch.java

Se não houver erros, um arquivo ArraySearch.class será criado.

Execute o código compilado:

java ArraySearch

Você deve ver a seguinte saída:

Cherry was found in the array.

Agora, tente alterar o searchElement para algo que não está no array, como "Grape", salve o arquivo, recompil e execute-o novamente para ver a saída diferente.

Usar Arrays.stream() para Verificação de Elemento

Nesta etapa, você aprenderá uma maneira mais moderna e, muitas vezes, mais concisa de verificar a existência de um elemento em um array Java usando a API Streams, especificamente Arrays.stream(). Essa abordagem aproveita os conceitos de programação funcional e pode tornar seu código mais legível para certas tarefas.

Modificaremos o arquivo ArraySearch.java que você criou na etapa anterior. Abra ~/project/ArraySearch.java no editor WebIDE.

Substitua o código existente pelo seguinte:

import java.util.Arrays;

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Use Arrays.stream() to check if the element exists
        boolean found = Arrays.stream(fruits).anyMatch(fruit -> fruit.equals(searchElement));

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }
    }
}

Vamos analisar as mudanças:

import java.util.Arrays;: Precisamos importar a classe Arrays para usar seu método stream().
boolean found = Arrays.stream(fruits).anyMatch(fruit -> fruit.equals(searchElement));: Este é o núcleo da nova abordagem.
- Arrays.stream(fruits): Isso converte o array fruits em um Stream. Um stream é uma sequência de elementos que suporta várias operações.
- .anyMatch(fruit -> fruit.equals(searchElement)): Esta é uma operação de stream. anyMatch() verifica se qualquer elemento no stream corresponde à condição fornecida. A condição é fornecida como uma expressão lambda fruit -> fruit.equals(searchElement). Essa expressão lambda pega cada fruit do stream e verifica se ele é igual ao searchElement. Se uma correspondência for encontrada, anyMatch() retorna true imediatamente.

Essa abordagem baseada em stream atinge o mesmo resultado que o loop for, mas em um estilo mais declarativo – você descreve o que deseja fazer (encontrar se algum elemento corresponde à condição) em vez de como fazê-lo (iterar passo a passo).

Salve o arquivo ArraySearch.java (Ctrl+S ou Cmd+S).

Agora, compile e execute o programa modificado no terminal do diretório ~/project:

Compile o código:

javac ArraySearch.java

Execute o código compilado:

java ArraySearch

Você deve ver a mesma saída que antes:

Cherry was found in the array.

Novamente, sinta-se à vontade para alterar o searchElement para testar o caso else.

Lidar com Elementos Nulos

Nesta etapa, consideraremos um cenário comum em Java: lidar com valores null em arrays. Se um array contiver elementos null, nossos métodos anteriores podem encontrar problemas. Aprenderemos como lidar com nulls com segurança ao pesquisar um elemento.

Abra o arquivo ~/project/ArraySearch.java no editor WebIDE novamente.

Modifique o array fruits para incluir um elemento null:

import java.util.Arrays;
import java.util.Objects; // Import the Objects class

public class ArraySearch {

    public static void main(String[] args) {
        // Define an array of strings with a null element
        String[] fruits = {"Apple", null, "Banana", "Cherry", "Date", "Elderberry"};

        // The element we want to search for
        String searchElement = "Cherry";

        // Use Arrays.stream() and handle nulls
        boolean found = Arrays.stream(fruits)
                              .anyMatch(fruit -> Objects.equals(fruit, searchElement)); // Use Objects.equals

        // Print the result
        if (found) {
            System.out.println(searchElement + " was found in the array.");
        } else {
            System.out.println(searchElement + " was not found in the array.");
        }

        // Let's also search for null itself
        String searchNullElement = null;
        boolean foundNull = Arrays.stream(fruits)
                                  .anyMatch(fruit -> Objects.equals(fruit, searchNullElement));

        if (foundNull) {
            System.out.println("null was found in the array.");
        } else {
            System.out.println("null was not found in the array.");
        }
    }
}

Aqui está o que mudamos:

import java.util.Objects;: Importamos a classe Objects, que fornece métodos utilitários para objetos, incluindo o tratamento seguro de null.
String[] fruits = {"Apple", null, "Banana", "Cherry", "Date", "Elderberry"};: Adicionamos null como o segundo elemento no array fruits.
.anyMatch(fruit -> Objects.equals(fruit, searchElement)): Em vez de fruit.equals(searchElement), agora usamos Objects.equals(fruit, searchElement). O método Objects.equals() foi projetado para lidar com valores null de forma adequada. Ele retorna true se ambos os argumentos forem null e evita lançar uma NullPointerException se o primeiro argumento (fruit, neste caso) for null.
Adicionamos uma segunda pesquisa para demonstrar a localização do próprio null no array usando o mesmo método Objects.equals().

Salve o arquivo ArraySearch.java (Ctrl+S ou Cmd+S).

Compile e execute o programa modificado no terminal do diretório ~/project:

Compile o código:

javac ArraySearch.java

Execute o código compilado:

java ArraySearch

Você deve ver a seguinte saída, demonstrando que tanto "Cherry" quanto null foram encontrados:

Cherry was found in the array.
null was found in the array.

Usar Objects.equals() é a maneira recomendada de comparar objetos, especialmente quando há a possibilidade de um ou ambos os objetos serem null. Isso evita erros inesperados de NullPointerException.

Resumo

Neste laboratório, você aprendeu um método fundamental para verificar se um elemento específico existe dentro de um array Java: iterar pelo array usando um loop for tradicional. Você praticou a criação de um arquivo Java, a definição de um array e um elemento de pesquisa, a implementação do loop para comparar elementos e o uso de uma flag booleana para rastrear se o elemento foi encontrado. Este exercício prático demonstrou como realizar uma operação de pesquisa básica e imprimir o resultado com base na presença ou ausência do elemento no array.