Como Verificar se uma String Pode Ser Convertida em um Double em Java

Introdução

Neste laboratório, você aprenderá como determinar se uma determinada string pode ser convertida com sucesso em um número de ponto flutuante de dupla precisão em Java. Exploraremos o processo de tentar analisar uma string usando Double.parseDouble(), entender como lidar com potenciais erros NumberFormatException que podem ocorrer se a string não for uma representação numérica válida e discutiremos métodos para verificar se uma string adere a um formato decimal válido. Ao final deste laboratório, você estará equipado com o conhecimento para converter strings em doubles de forma segura e eficaz em suas aplicações Java.

Tentar a Análise com Double.parseDouble()

Nesta etapa, aprenderemos como converter uma representação em string de um número em um tipo numérico em Java. Esta é uma tarefa comum quando você recebe entrada de um usuário ou lê dados de um arquivo, pois a entrada é frequentemente lida inicialmente como texto (strings).

Java oferece várias maneiras de realizar essa conversão. Um dos métodos mais comuns para converter uma string em um número de ponto flutuante de dupla precisão é usando o método Double.parseDouble().

Vamos criar um programa Java simples para demonstrar isso.

Abra o arquivo HelloJava.java no editor WebIDE, caso ainda não esteja aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
import java.util.Scanner;

public class HelloJava {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter a decimal number: ");
        String userInput = scanner.nextLine();

        // Attempt to parse the input string into a double
        double number = Double.parseDouble(userInput);

        System.out.println("You entered: " + number);

        scanner.close();
    }
}
```
Vamos analisar as novas partes deste código:
- System.out.print("Enter a decimal number: ");: Esta linha solicita ao usuário que insira um número decimal.
- String userInput = scanner.nextLine();: Isso lê a entrada do usuário como uma string e a armazena na variável userInput.
- double number = Double.parseDouble(userInput);: Este é o núcleo desta etapa. Double.parseDouble() pega a string userInput e tenta convertê-la em um valor double. Se a string puder ser interpretada com sucesso como um número decimal, o valor double resultante é armazenado na variável number.
- System.out.println("You entered: " + number);: Esta linha imprime o valor double analisado de volta para o usuário.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, compile o programa modificado. Abra o Terminal na parte inferior do WebIDE e certifique-se de estar no diretório ~/project. Em seguida, execute:
```
javac HelloJava.java
```
Se a compilação for bem-sucedida, você não verá nenhuma saída.
Finalmente, execute o programa:
```
java HelloJava
```
O programa solicitará que você insira um número decimal. Digite um número decimal válido, como 123.45, e pressione Enter.
```
Enter a decimal number: 123.45
You entered: 123.45
```
O programa deve analisar com sucesso sua entrada e imprimir o número de volta para você.

Nesta etapa, você usou com sucesso Double.parseDouble() para converter uma representação de string válida de um número decimal em um double. No entanto, o que acontece se o usuário inserir algo que não é um número válido? Exploraremos isso na próxima etapa.

Lidar com NumberFormatException

Na etapa anterior, vimos como Double.parseDouble() funciona quando a string de entrada é um número decimal válido. Mas o que acontece se o usuário inserir texto que não pode ser convertido em um número? Vamos tentar.

Certifique-se de estar no diretório ~/project no Terminal.
Execute o programa novamente:
```
java HelloJava
```
Quando solicitado a inserir um número decimal, digite algo que claramente não é um número, como hello ou abc.
```
Enter a decimal number: hello
```
Pressione Enter. Você provavelmente verá muito texto vermelho no Terminal. Esta é uma mensagem de erro, especificamente um NumberFormatException.
```
Exception in thread "main" java.lang.NumberFormatException: For input string: "hello"
    at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2050)
    at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
    at java.base/java.lang.Double.parseDouble(Double.java:651)
    at HelloJava.main(HelloJava.java:10)
```
Este NumberFormatException ocorre porque a string "hello" não pode ser analisada em um valor double válido. Quando uma exceção como esta acontece e não é tratada, o programa trava e para de ser executado.

Em aplicações do mundo real, você não quer que seu programa trave só porque um usuário insere uma entrada inválida. Você precisa de uma maneira de lidar com esses erros de forma elegante. Em Java, usamos blocos try-catch para lidar com exceções.

Um bloco try-catch funciona assim:
- O código que pode causar uma exceção é colocado dentro do bloco try.
- Se uma exceção ocorrer dentro do bloco try, o código dentro do bloco catch é executado.
- Se nenhuma exceção ocorrer, o bloco catch é ignorado.

Vamos modificar nosso programa para usar um bloco try-catch para lidar com o NumberFormatException.

Abra o arquivo HelloJava.java no editor WebIDE.

Modifique o código para envolver a chamada Double.parseDouble() dentro de um bloco try-catch:

import java.util.Scanner;

public class HelloJava {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter a decimal number: ");
        String userInput = scanner.nextLine();

        try {
            // Attempt to parse the input string into a double
            double number = Double.parseDouble(userInput);
            System.out.println("You entered: " + number);
        } catch (NumberFormatException e) {
            // This code runs if a NumberFormatException occurs
            System.out.println("Invalid input. Please enter a valid decimal number.");
        }

        scanner.close();
    }
}

Neste código atualizado:

A linha Double.parseDouble(userInput); está dentro do bloco try.
O bloco catch (NumberFormatException e) especifica que, se um NumberFormatException ocorrer no bloco try, o código dentro do bloco catch deve ser executado.
Dentro do bloco catch, imprimimos uma mensagem de erro amigável para o usuário em vez de deixar o programa travar.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado:
```
javac HelloJava.java
```
Execute o programa novamente:
```
java HelloJava
```
Quando solicitado, insira uma entrada inválida como hello novamente.
```
Enter a decimal number: hello
Invalid input. Please enter a valid decimal number.
```
Desta vez, em vez de travar, o programa capturou o NumberFormatException e imprimiu a mensagem do bloco catch. Esta é uma experiência de usuário muito melhor!

Você agora aprendeu como usar blocos try-catch para lidar com exceções como NumberFormatException, tornando seus programas mais robustos e fáceis de usar.

Verificar Formato Decimal Válido

Na etapa anterior, lidamos com sucesso com o NumberFormatException usando um bloco try-catch. Isso impede que nosso programa trave quando a entrada não é um número válido. No entanto, a abordagem atual ainda tenta analisar a string e só captura o erro depois que a análise falha.

Uma abordagem mais proativa é verificar se a string de entrada tem um formato decimal válido antes de tentar analisá-la. Isso pode ser feito usando expressões regulares ou outras técnicas de validação. Para este laboratório, usaremos uma verificação simples dentro de um loop para solicitar repetidamente a entrada do usuário até que um número decimal válido seja fornecido.

Esta abordagem combina o bloco try-catch com um loop para garantir que recebemos uma entrada válida.

Abra o arquivo HelloJava.java no editor WebIDE.

Modifique o código para incluir um loop que continue até que a entrada válida seja recebida:

import java.util.Scanner;

public class HelloJava {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double number = 0.0; // Initialize with a default value
        boolean validInput = false; // Flag to track valid input

        while (!validInput) {
            System.out.print("Enter a decimal number: ");
            String userInput = scanner.nextLine();

            try {
                // Attempt to parse the input string into a double
                number = Double.parseDouble(userInput);
                validInput = true; // Set flag to true if parsing is successful
            } catch (NumberFormatException e) {
                // This code runs if a NumberFormatException occurs
                System.out.println("Invalid input. Please enter a valid decimal number.");
            }
        }

        System.out.println("You entered a valid number: " + number);

        scanner.close();
    }
}

Vamos analisar as mudanças:

double number = 0.0;: Inicializamos a variável number fora do loop.
boolean validInput = false;: Introduzimos uma variável booleana validInput para controlar o loop. Ela é inicialmente false.
while (!validInput): Isso cria um loop while que continua enquanto validInput for false.
Dentro do bloco try, se Double.parseDouble() for bem-sucedido, definimos validInput como true. Isso fará com que o loop termine após a iteração atual.
Se um NumberFormatException ocorrer, o bloco catch é executado, validInput permanece false e o loop continuará, solicitando a entrada do usuário novamente.
Após o término do loop (significando que validInput é true), imprimimos uma mensagem confirmando que a entrada válida foi recebida.

Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado:
```
javac HelloJava.java
```
Execute o programa:
```
java HelloJava
```

Agora, tente inserir uma entrada inválida primeiro e, em seguida, insira um número decimal válido.

Enter a decimal number: abc
Invalid input. Please enter a valid decimal number.
Enter a decimal number: 1.2.3
Invalid input. Please enter a valid decimal number.
Enter a decimal number: 789.01
You entered a valid number: 789.01

O programa continuará pedindo entrada até que você forneça uma string que Double.parseDouble() possa converter com sucesso.

Você agora implementou um loop básico de validação de entrada que garante que seu programa receba um número decimal válido do usuário antes de prosseguir. Este é um padrão fundamental para lidar com a entrada do usuário em muitas aplicações.

Resumo

Neste laboratório, aprendemos como verificar se uma string pode ser convertida em um double em Java. Começamos tentando analisar uma string em um double usando o método Double.parseDouble(). Este método é uma maneira comum de converter representações de strings de números em tipos numéricos, particularmente útil ao lidar com a entrada do usuário ou dados lidos de arquivos. Implementamos um programa Java simples que solicita a entrada do usuário, lê-a como uma string e, em seguida, usa Double.parseDouble() para convertê-la em um double, demonstrando o processo básico de conversão de string para double.