Cómo verificar si una cadena se puede convertir en un número de punto flotante en Java

Introducción

En este laboratorio, aprenderás cómo determinar si una cadena dada se puede convertir con éxito en un número de punto flotante de doble precisión en Java. Exploraremos el proceso de intentar analizar una cadena utilizando Double.parseDouble(), entenderemos cómo manejar los posibles errores de NumberFormatException que pueden ocurrir si la cadena no es una representación numérica válida y discutiremos métodos para verificar si una cadena sigue un formato decimal válido. Al final de este laboratorio, estarás equipado con el conocimiento para convertir cadenas en números de punto flotante de manera segura y efectiva en tus aplicaciones Java.

Intentar el análisis con Double.parseDouble()

En este paso, aprenderemos cómo convertir una representación de cadena de un número en un tipo numérico en Java. Esta es una tarea común cuando se recibe entrada de un usuario o se lee datos de un archivo, ya que la entrada a menudo se lee inicialmente como texto (cadenas).

Java proporciona varias formas de realizar esta conversión. Uno de los métodos más comunes para convertir una cadena en un número de punto flotante de doble precisión es utilizar el método Double.parseDouble().

Vamos a crear un sencillo programa de Java para demostrar esto.

Abre el archivo HelloJava.java en el editor del WebIDE si no está abierto.
Reemplaza todo el contenido del archivo con el siguiente 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();
    }
}
```
Veamos las nuevas partes de este código:
- System.out.print("Enter a decimal number: ");: Esta línea solicita al usuario que ingrese un número decimal.
- String userInput = scanner.nextLine();: Esto lee la entrada del usuario como una cadena y la almacena en la variable userInput.
- double number = Double.parseDouble(userInput);: Este es el núcleo de este paso. Double.parseDouble() toma la cadena userInput e intenta convertirla en un valor double. Si la cadena se puede interpretar correctamente como un número decimal, el valor double resultante se almacena en la variable number.
- System.out.println("You entered: " + number);: Esta línea imprime el valor double analizado de vuelta al usuario.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, compila el programa modificado. Abre la Terminal en la parte inferior del WebIDE y asegúrate de estar en el directorio ~/project. Luego ejecuta:
```
javac HelloJava.java
```
Si la compilación es exitosa, no verás salida alguna.
Finalmente, ejecuta el programa:
```
java HelloJava
```
El programa te solicitará que ingreses un número decimal. Escribe un número decimal válido, como 123.45, y presiona Enter.
```
Enter a decimal number: 123.45
You entered: 123.45
```
El programa debería analizar correctamente tu entrada e imprimir el número de vuelta a ti.

En este paso, has utilizado con éxito Double.parseDouble() para convertir una representación de cadena válida de un número decimal en un double. Sin embargo, ¿qué pasa si el usuario ingresa algo que no es un número válido? Exploraremos esto en el siguiente paso.

Manejar la NumberFormatException

En el paso anterior, vimos cómo funciona Double.parseDouble() cuando la cadena de entrada es un número decimal válido. Pero, ¿qué pasa si el usuario ingresa texto que no se puede convertir en un número? Vamos a probarlo.

Asegúrate de estar en el directorio ~/project en la Terminal.
Ejecuta el programa nuevamente:
```
java HelloJava
```
Cuando se te solicite ingresar un número decimal, escribe algo que claramente no es un número, como hello o abc.
```
Enter a decimal number: hello
```
Presiona Enter. Probablemente verás mucho texto rojo en la Terminal. Este es un mensaje de error, específicamente una 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)
```
Esta NumberFormatException ocurre porque la cadena "hello" no se puede analizar en un valor double válido. Cuando ocurre una excepción como esta y no se maneja, el programa se bloquea y deja de ejecutarse.

En aplicaciones del mundo real, no quieres que tu programa se bloquee solo porque un usuario ingresa una entrada no válida. Necesitas una forma de manejar elegante estos errores. En Java, usamos bloques try-catch para manejar excepciones.

Un bloque try-catch funciona de la siguiente manera:
- El código que puede causar una excepción se coloca dentro del bloque try.
- Si ocurre una excepción dentro del bloque try, se ejecuta el código dentro del bloque catch.
- Si no ocurre ninguna excepción, se omite el bloque catch.

Vamos a modificar nuestro programa para usar un bloque try-catch para manejar la NumberFormatException.

Abre el archivo HelloJava.java en el editor del WebIDE.

Modifica el código para envolver la llamada a Double.parseDouble() dentro de un bloque 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();
    }
}

En este código actualizado:

La línea Double.parseDouble(userInput); está dentro del bloque try.
El bloque catch (NumberFormatException e) especifica que si ocurre una NumberFormatException en el bloque try, se debe ejecutar el código dentro del bloque catch.
Dentro del bloque catch, imprimimos un mensaje de error amigable para el usuario en lugar de dejar que el programa se bloquee.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado:
```
javac HelloJava.java
```
Ejecuta el programa nuevamente:
```
java HelloJava
```
Cuando se te solicite, ingresa una entrada no válida como hello de nuevo.
```
Enter a decimal number: hello
Invalid input. Please enter a valid decimal number.
```
Esta vez, en lugar de bloquearse, el programa capturó la NumberFormatException e imprimió el mensaje del bloque catch. ¡Esta es una experiencia de usuario mucho mejor!

Ahora has aprendido cómo usar bloques try-catch para manejar excepciones como NumberFormatException, lo que hace que tus programas sean más robustos y amigables para el usuario.

Verificar el formato decimal válido

En el paso anterior, manejamos con éxito la NumberFormatException utilizando un bloque try-catch. Esto evita que nuestro programa se bloquee cuando la entrada no es un número válido. Sin embargo, el enfoque actual todavía intenta analizar la cadena y solo captura el error después de que el análisis falle.

Un enfoque más proactivo es verificar si la cadena de entrada tiene un formato decimal válido antes de intentar analizarla. Esto se puede hacer utilizando expresiones regulares u otras técnicas de validación. Para este laboratorio, usaremos una simple comprobación dentro de un bucle para pedir repetidamente al usuario una entrada hasta que se proporcione un número decimal válido.

Este enfoque combina el bloque try-catch con un bucle para asegurarnos de obtener una entrada válida.

Abre el archivo HelloJava.java en el editor del WebIDE.

Modifica el código para incluir un bucle que continúe hasta que se reciba una entrada válida:

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();
    }
}

Veamos los cambios:

double number = 0.0;: Inicializamos la variable number fuera del bucle.
boolean validInput = false;: Introducimos una variable booleana validInput para controlar el bucle. Inicialmente es false.
while (!validInput): Esto crea un bucle while que continúa mientras validInput sea false.
Dentro del bloque try, si Double.parseDouble() tiene éxito, establecemos validInput en true. Esto hará que el bucle termine después de la iteración actual.
Si ocurre una NumberFormatException, se ejecuta el bloque catch, validInput sigue siendo false y el bucle continuará, solicitando al usuario una entrada nuevamente.
Después de que el bucle termine (lo que significa que validInput es true), imprimimos un mensaje confirmando que se recibió una entrada válida.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado:
```
javac HelloJava.java
```
Ejecuta el programa:
```
java HelloJava
```

Ahora, intenta ingresar una entrada no válida primero y luego ingresa un 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

El programa seguirá pidiendo una entrada hasta que proporciones una cadena que Double.parseDouble() pueda convertir con éxito.

Ahora has implementado un bucle básico de validación de entrada que asegura que tu programa reciba un número decimal válido del usuario antes de continuar. Este es un patrón fundamental para manejar la entrada del usuario en muchas aplicaciones.

Resumen

En este laboratorio, aprendimos cómo verificar si una cadena se puede convertir en un número de punto flotante (double) en Java. Comenzamos intentando analizar una cadena en un número de punto flotante utilizando el método Double.parseDouble(). Este método es una forma común de convertir representaciones de cadenas de números en tipos numéricos, especialmente útil cuando se maneja la entrada del usuario o los datos leídos de archivos. Implementamos un simple programa en Java que solicita al usuario una entrada, la lee como una cadena y luego utiliza Double.parseDouble() para convertirla en un número de punto flotante, demostrando el proceso básico de conversión de cadena a número de punto flotante.