LabEx
EntrarJunte-se

Como Verificar se uma String é Nula em Java

JavaBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá técnicas essenciais para lidar com strings nulas em Java. Começaremos explorando o método fundamental de verificação de nulo usando o operador de igualdade (==), compreendendo por que isso é crucial para prevenir NullPointerException.

Em seguida, você aprenderá como combinar verificações de nulo com verificações de strings vazias para lidar com vários estados de string de forma eficaz. Finalmente, apresentaremos a classe Optional como uma abordagem moderna e mais segura para gerenciar valores potencialmente nulos, demonstrando como ela pode melhorar a legibilidade do código e prevenir erros comuns.

Testar Nulos Usando o Operador de Igualdade

Nesta etapa, aprenderemos como verificar se uma variável string em Java é null usando o operador de igualdade (==). Compreender como lidar com null é crucial na programação Java para evitar erros.

Em Java, uma variável de um tipo de referência (como String) pode conter um valor especial chamado null. Isso significa que a variável não se refere a nenhum objeto na memória. Tentar usar uma variável null como se fosse um objeto válido resultará em um NullPointerException, que é um erro comum e frustrante para iniciantes.

A maneira mais simples de verificar se uma string é null é usando o operador de igualdade (==).

Vamos criar um programa Java simples para demonstrar isso.

  1. Abra o WebIDE e certifique-se de que está no diretório ~/project. Você pode confirmar isso olhando para o prompt do terminal ou digitando pwd e pressionando Enter.

  2. Crie um novo arquivo Java chamado NullCheck.java no diretório ~/project. Você pode fazer isso clicando com o botão direito no File Explorer à esquerda, selecionando "New File" e digitando NullCheck.java.

  3. Abra o arquivo NullCheck.java no editor e cole o seguinte código:

    public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // This is an empty string, not null

        System.out.println("Checking myString1:");
        if (myString1 == null) {
            System.out.println("myString1 is null");
        } else {
            System.out.println("myString1 is not null");
        }

        System.out.println("\nChecking myString2:");
        if (myString2 == null) {
            System.out.println("myString2 is null");
        } else {
            System.out.println("myString2 is not null");
        }

        System.out.println("\nChecking myString3:");
        if (myString3 == null) {
            System.out.println("myString3 is null");
        } else {
            System.out.println("myString3 is not null");
        }
    }
}

    Neste código:

    • Declaramos três variáveis String: myString1 recebe uma string regular, myString2 recebe explicitamente null e myString3 recebe uma string vazia ("").
    • Usamos uma instrução if com o operador de igualdade (==) para verificar se cada string é null.
    • Imprimimos uma mensagem indicando se a string é null ou não.

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

  5. Abra o Terminal na parte inferior do WebIDE. Certifique-se de que está no diretório ~/project.

  6. Compile o programa Java usando o comando javac:

    javac NullCheck.java

    Se não houver erros, este comando criará um arquivo NullCheck.class no mesmo diretório.

  7. Execute o programa Java compilado usando o comando java:

    java NullCheck

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

    Checking myString1:
myString1 is not null

Checking myString2:
myString2 is null

Checking myString3:
myString3 is not null

Esta saída confirma que myString1 e myString3 não são null, enquanto myString2 é null. É importante notar a diferença entre uma string null e uma string vazia (""). Uma string vazia é um objeto String válido com zero caracteres, enquanto uma variável string null não aponta para nenhum objeto.

Usar == null é a maneira padrão e correta de verificar se uma variável de referência é null em Java.

Combinar Verificações de Nulo e Vazio

Na etapa anterior, aprendemos como verificar se uma string é null. No entanto, em muitos cenários do mundo real, você também pode precisar verificar se uma string está vazia (tem zero caracteres) ou contém apenas espaços em branco. Uma string que é null, vazia ou contém apenas espaços em branco é frequentemente considerada "em branco" ou "efetivamente vazia".

Verificar tanto null quanto strings vazias é um requisito comum. Você pode combinar essas verificações usando o operador lógico OR (||).

Vamos modificar nosso programa anterior para incluir verificações para strings null e vazias.

  1. Abra o arquivo NullCheck.java no editor WebIDE.

  2. Modifique o método main para incluir uma string vazia e combinar as verificações. Substitua o método main existente pelo seguinte código:

    public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // This is an empty string
        String myString4 = "   "; // This string contains only whitespace

        System.out.println("Checking myString1:");
        if (myString1 == null || myString1.isEmpty()) {
            System.out.println("myString1 is null or empty");
        } else {
            System.out.println("myString1 is not null and not empty");
        }

        System.out.println("\nChecking myString2:");
        if (myString2 == null || myString2.isEmpty()) {
            System.out.println("myString2 is null or empty");
        } else {
            System.out.println("myString2 is not null and not empty");
        }

        System.out.println("\nChecking myString3:");
        if (myString3 == null || myString3.isEmpty()) {
            System.out.println("myString3 is null or empty");
        } else {
            System.out.println("myString3 is not null and not empty");
        }

        System.out.println("\nChecking myString4:");
        // Note: isEmpty() does not check for whitespace
        if (myString4 == null || myString4.isEmpty()) {
            System.out.println("myString4 is null or empty");
        } else {
            System.out.println("myString4 is not null and not empty");
        }
    }
}

    Neste código atualizado:

    • Adicionamos myString4, que contém apenas espaços em branco.
    • Usamos a condição myString == null || myString.isEmpty() para verificar se uma string é null ou vazia. O método isEmpty() é um método String embutido que retorna true se a string tiver um comprimento de 0.
    • Importante: O método isEmpty() só pode ser chamado em uma string não nula. Se você tentar chamar isEmpty() em uma string null, você obterá um NullPointerException. Portanto, é crucial verificar null primeiro usando myString == null antes de chamar myString.isEmpty(). O operador lógico OR (||) é "short-circuiting", o que significa que se a primeira condição (myString == null) for verdadeira, a segunda condição (myString.isEmpty()) não é avaliada, prevenindo o NullPointerException.

  3. Salve o arquivo NullCheck.java.

  4. Compile o programa modificado no Terminal:

    javac NullCheck.java

  5. Execute o programa compilado:

    java NullCheck

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

    Checking myString1:
myString1 is not null and not empty

Checking myString2:
myString2 is null or empty

Checking myString3:
myString3 is null or empty

Checking myString4:
myString4 is not null and not empty

Observe que myString4 (que contém apenas espaços em branco) é considerado "not null and not empty" por esta verificação. Se você também precisar considerar strings com apenas espaços em branco como "em branco", você pode usar o método isBlank() (disponível desde Java 11).

Vamos atualizar rapidamente o código para usar isBlank() para myString4:

  1. Modifique a verificação para myString4 em NullCheck.java:

    // ... (previous code) ...

        System.out.println("\nChecking myString4 with isBlank():");
        if (myString4 == null || myString4.isBlank()) {
            System.out.println("myString4 is null or blank");
        } else {
            System.out.println("myString4 is not null and not blank");
        }
    }
}

  2. Salve o arquivo, compile e execute novamente:

    javac NullCheck.java
java NullCheck

    A saída para myString4 agora deve ser:

    Checking myString4 with isBlank():
myString4 is null or blank

Isso demonstra como combinar verificações para strings null e vazias/em branco, que é um padrão muito comum na programação Java.

Usar Optional para Lidar com Strings Nulas de Forma Segura

Nas etapas anteriores, usamos o operador de igualdade (==) e os métodos isEmpty() ou isBlank() para verificar strings null e vazias/em branco. Embora esses métodos sejam eficazes, o Java 8 introduziu a classe Optional como uma forma de lidar com valores potencialmente null de uma maneira mais explícita e funcional. Usar Optional pode ajudar a tornar seu código mais legível e menos propenso a NullPointerExceptions.

Optional é um objeto contêiner que pode ou não conter um valor não nulo. Se um valor estiver presente, isPresent() retornará true e get() retornará o valor. Se nenhum valor estiver presente, o objeto é considerado vazio e isPresent() retornará false. Chamar get() em um Optional vazio lançará um NoSuchElementException.

Vamos explorar como usar Optional com strings.

  1. Abra o arquivo NullCheck.java no editor WebIDE.

  2. Substitua todo o conteúdo do arquivo pelo seguinte código que usa Optional:

    import java.util.Optional;

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = "";
        String myString4 = "   ";

        // Creating Optional objects from strings
        Optional<String> optionalString1 = Optional.ofNullable(myString1);
        Optional<String> optionalString2 = Optional.ofNullable(myString2);
        Optional<String> optionalString3 = Optional.ofNullable(myString3);
        Optional<String> optionalString4 = Optional.ofNullable(myString4);

        System.out.println("Checking optionalString1:");
        if (optionalString1.isPresent()) {
            System.out.println("optionalString1 has a value: " + optionalString1.get());
        } else {
            System.out.println("optionalString1 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString2:");
        if (optionalString2.isPresent()) {
            System.out.println("optionalString2 has a value: " + optionalString2.get());
        } else {
            System.out.println("optionalString2 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString3:");
        // Optional.ofNullable("") creates an Optional containing an empty string
        if (optionalString3.isPresent()) {
            System.out.println("optionalString3 has a value: " + optionalString3.get());
        } else {
            System.out.println("optionalString3 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString4:");
         if (optionalString4.isPresent()) {
            System.out.println("optionalString4 has a value: " + optionalString4.get());
        } else {
            System.out.println("optionalString4 is empty (contains null)");
        }

        // Using Optional methods for safer handling
        System.out.println("\nUsing Optional methods:");

        // orElse: provides a default value if the Optional is empty
        String value1 = optionalString1.orElse("Default Value");
        String value2 = optionalString2.orElse("Default Value");
        System.out.println("Value from optionalString1 (orElse): " + value1);
        System.out.println("Value from optionalString2 (orElse): " + value2);

        // ifPresent: performs an action if a value is present
        System.out.print("If optionalString1 is present: ");
        optionalString1.ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("If optionalString2 is present: ");
        optionalString2.ifPresent(s -> System.out.println("Value is " + s));

        // filter: filters the value if present
        System.out.print("Filtered optionalString1 (length > 3): ");
        optionalString1.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("Filtered optionalString3 (length > 3): ");
        optionalString3.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));
    }
}

    Neste código:

    • Importamos a classe Optional.
    • Usamos Optional.ofNullable(string) para criar um Optional<String> a partir de um String regular. Este método é seguro para usar mesmo se a string de entrada for null. Se a entrada for null, ele retorna um Optional vazio; caso contrário, ele retorna um Optional contendo a string.
    • Usamos optionalString.isPresent() para verificar se o Optional contém um valor.
    • Usamos optionalString.get() para recuperar o valor se ele estiver presente. Tenha cuidado: chamar get() em um Optional vazio lançará uma exceção, então sempre verifique isPresent() primeiro ou use outros métodos mais seguros.
    • Demonstramos orElse(defaultValue) que retorna o valor contido se presente, caso contrário, retorna o valor padrão especificado.
    • Demonstramos ifPresent(consumer) que executa o consumidor fornecido (uma função que recebe um argumento e não retorna nenhum resultado) se um valor estiver presente.
    • Demonstramos filter(predicate) que retorna um Optional contendo o valor se ele estiver presente e corresponder ao predicado fornecido (uma função que retorna um booleano), caso contrário, retorna um Optional vazio.

  3. Salve o arquivo NullCheck.java.

  4. Compile o programa no Terminal:

    javac NullCheck.java

  5. Execute o programa:

    java NullCheck

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

    Checking optionalString1:
optionalString1 has a value: Hello

Checking optionalString2:
optionalString2 is empty (contains null)

Checking optionalString3:
optionalString3 has a value:

Checking optionalString4:
optionalString4 has a value:

Using Optional methods:
Value from optionalString1 (orElse): Hello
Value from optionalString2 (orElse): Default Value
If optionalString1 is present: Value is Hello
If optionalString2 is present:
Filtered optionalString1 (length > 3): Value is Hello
Filtered optionalString3 (length > 3):

Usar Optional pode tornar seu código mais expressivo sobre se um valor pode estar ausente e fornece métodos úteis para lidar com a presença ou ausência de um valor sem verificações explícitas de null em todos os lugares. Embora Optional seja uma ferramenta poderosa, não é um substituto para todas as verificações de null, mas é particularmente útil ao lidar com valores de retorno que podem ser null.

Resumo

Neste laboratório, aprendemos como verificar se uma string em Java é null. Começamos usando o operador de igualdade (==) para comparar diretamente uma variável string com null, entendendo que null significa a ausência de uma referência de objeto e que não verificar null pode levar a NullPointerException.

Em seguida, exploramos como combinar a verificação de nulo com uma verificação de string vazia, reconhecendo que uma string vazia ("") é um objeto válido, ao contrário de null. Finalmente, aprendemos como usar a classe Optional, introduzida no Java 8, como uma maneira mais moderna e segura de lidar com valores potencialmente nulos, promovendo um código mais robusto e legível, indicando explicitamente a possibilidade de um valor ausente.

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