Cómo comprobar si una cadena es numérica en Java

Introducción

En este laboratorio, aprenderás diferentes métodos para verificar si una cadena dada en Java representa un valor numérico. Comenzaremos explorando cómo intentar analizar una cadena en un entero y manejar los posibles errores cuando la cadena no es un número válido.

A continuación, descubrirás cómo aprovechar el poder de las expresiones regulares para una comprobación numérica más flexible y robusta. Finalmente, ampliaremos nuestra comprensión para manejar cadenas que representen números negativos y valores decimales, asegurándonos de que nuestras comprobaciones numéricas sean exhaustivas.

Skills Graph

Intentar analizar una cadena a entero

En este paso, exploraremos cómo convertir una cadena (texto) en un entero (un número entero) en Java. Esta es una tarea común en la programación, especialmente cuando necesitas obtener una entrada numérica de un usuario o leer números de un archivo.

Java proporciona una forma incorporada de hacer esto utilizando el método Integer.parseInt(). Sin embargo, ¿qué sucede si la cadena en realidad no representa un número válido? Vamos a averiguarlo escribiendo un sencillo programa en Java.

1. Abre el archivo HelloJava.java en el editor WebIDE si no está abierto.

2. Reemplaza todo el contenido del archivo con el siguiente código:

   public class HelloJava {
       public static void main(String[] args) {
           String numberString = "123";
           int number = Integer.parseInt(numberString);
           System.out.println("Successfully parsed: " + number);
   
           String invalidString = "abc";
           try {
               int invalidNumber = Integer.parseInt(invalidString);
               System.out.println("This line will not be reached.");
           } catch (NumberFormatException e) {
               System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");
               System.out.println("Exception details: " + e.getMessage());
           }
       }
   }

   Veamos las nuevas partes de este código:

   • String numberString = "123";: Creamos una variable de tipo cadena numberString y le asignamos el valor "123".
   • int number = Integer.parseInt(numberString);: Este es el núcleo de la conversión. Integer.parseInt() intenta convertir la cadena "123" en un entero. Dado que "123" es una representación válida de un entero, esto tendrá éxito y el valor entero 123 se almacenará en la variable number.
   • String invalidString = "abc";: Creamos otra variable de tipo cadena invalidString y le asignamos el valor "abc". Esta cadena no representa un entero válido.
   • try { ... } catch (NumberFormatException e) { ... }: Este es un bloque try-catch, que se utiliza para manejar errores (excepciones) en Java.
     • El código dentro del bloque try es donde ponemos la operación que podría causar un error. En este caso, es Integer.parseInt(invalidString).
     • Si Integer.parseInt("abc") falla porque "abc" no es un número válido, "lanzará" una NumberFormatException.
     • El bloque catch (NumberFormatException e) "atrapa" este tipo específico de excepción. Luego se ejecutará el código dentro del bloque catch.
   • System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");: Esta línea se imprimirá si se produce la NumberFormatException.
   • System.out.println("Exception details: " + e.getMessage());: Esto imprime un mensaje más específico sobre el error proporcionado por el objeto de excepción e.

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Compila el programa en la Terminal:

   javac HelloJava.java

   Si no hay errores, no verás salida.

5. Ejecuta el programa compilado:

   java HelloJava

   Deberías ver una salida similar a esta:

   Successfully parsed: 123
   Error: Could not parse 'abc' to an integer.
   Exception details: For input string: "abc"

   Esta salida muestra que el primer intento de análisis tuvo éxito, pero el segundo intento con la cadena no válida "abc" resultó en una NumberFormatException, y nuestro bloque catch la manejó adecuadamente imprimiendo un mensaje de error.

Esto demuestra la importancia de manejar los posibles errores al convertir cadenas en números, ya que no todas las cadenas se pueden analizar con éxito. Utilizar bloques try-catch es una forma estándar de manejar tales situaciones en Java.

Utilizar expresiones regulares para la comprobación numérica

En el paso anterior, vimos que Integer.parseInt() lanza una excepción si la cadena no es un entero válido. Si bien try-catch es útil para manejar el error cuando ocurre, a veces es posible que desees comprobar si una cadena se puede analizar como un número antes de intentar la conversión. Aquí es donde las Expresiones Regulares (Regex) resultan útiles.

Las Expresiones Regulares son patrones poderosos utilizados para coincidir con combinaciones de caracteres en cadenas. Podemos utilizar un patrón de regex sencillo para comprobar si una cadena está formada únicamente por dígitos.

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

2. Reemplaza todo el contenido del archivo con el siguiente código:

   public class HelloJava {
       public static void main(String[] args) {
           String numberString = "123";
           String invalidString = "abc";
           String mixedString = "123a";
   
           System.out.println("Checking string: \"" + numberString + "\"");
           if (numberString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
               int number = Integer.parseInt(numberString);
               System.out.println("  Parsed integer: " + number);
           } else {
               System.out.println("  Does not match the pattern.");
           }
   
           System.out.println("\nChecking string: \"" + invalidString + "\"");
           if (invalidString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
           } else {
               System.out.println("  Does not match the pattern.");
           }
   
           System.out.println("\nChecking string: \"" + mixedString + "\"");
           if (mixedString.matches("\\d+")) {
               System.out.println("  Matches the pattern (contains only digits).");
           } else {
               System.out.println("  Does not match the pattern.");
           }
       }
   }

   Analicemos las nuevas partes:

   • numberString.matches("\\d+"): Esta es la parte clave. El método matches() está disponible en todos los objetos String en Java. Comprueba si toda la cadena coincide con el patrón de expresión regular dado.
   • "\\d+": Este es el patrón de expresión regular.
     • \\d: Esto coincide con cualquier dígito (del 0 al 9). Usamos \\ porque \ es un carácter especial en las cadenas de Java, por lo que debemos escaparlo.
     • +: Este es un cuantificador que significa "uno o más" del elemento precedente. Entonces, \\d+ significa "uno o más dígitos".
   • La instrucción if comprueba el resultado de matches(). Si devuelve true, significa que la cadena está formada enteramente por uno o más dígitos. Si devuelve false, significa que la cadena contiene caracteres distintos de dígitos o está vacía.

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Compila el programa en la Terminal:

   javac HelloJava.java

   No deberías ver salida si la compilación es exitosa.

5. Ejecuta el programa compilado:

   java HelloJava

   Deberías ver una salida similar a esta:

   Checking string: "123"
     Matches the pattern (contains only digits).
     Parsed integer: 123
   
   Checking string: "abc"
     Does not match the pattern.
   
   Checking string: "123a"
     Does not match the pattern.

   Como puedes ver, la comprobación matches("\\d+") identificó correctamente que "123" contiene solo dígitos, mientras que "abc" y "123a" no coincidieron con el patrón. Este enfoque te permite validar el formato de la cadena antes de intentar analizarla, evitando potencialmente NumberFormatException en algunos casos.

Manejar números negativos y decimales

En los pasos anteriores, nos centramos en analizar números enteros positivos. Sin embargo, los números también pueden ser negativos o tener puntos decimales. En este paso, aprenderemos cómo manejar estos casos al convertir cadenas en números en Java.

Java proporciona diferentes métodos para analizar diferentes tipos de números:

• Integer.parseInt(): Para números enteros (enteros).
• Double.parseDouble(): Para números con puntos decimales (números de punto flotante).

Modifiquemos nuestro programa para manejar enteros negativos y números decimales.

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

2. Reemplaza todo el contenido del archivo con el siguiente código:

   public class HelloJava {
       public static void main(String[] args) {
           String positiveIntString = "456";
           String negativeIntString = "-789";
           String decimalString = "123.45";
           String invalidString = "not a number";
   
           // Handling Integers (positive and negative)
           System.out.println("Attempting to parse integers:");
           try {
               int positiveInt = Integer.parseInt(positiveIntString);
               System.out.println("  Parsed '" + positiveIntString + "' as integer: " + positiveInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + positiveIntString + "' as integer.");
           }
   
           try {
               int negativeInt = Integer.parseInt(negativeIntString);
               System.out.println("  Parsed '" + negativeIntString + "' as integer: " + negativeInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + negativeIntString + "' as integer.");
           }
   
           try {
               int decimalAsInt = Integer.parseInt(decimalString);
               System.out.println("  Parsed '" + decimalString + "' as integer: " + decimalAsInt);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + decimalString + "' as integer.");
           }
   
           // Handling Decimal Numbers
           System.out.println("\nAttempting to parse decimal numbers:");
           try {
               double decimal = Double.parseDouble(decimalString);
               System.out.println("  Parsed '" + decimalString + "' as double: " + decimal);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + decimalString + "' as double.");
           }
   
           try {
               double intAsDouble = Double.parseDouble(positiveIntString);
               System.out.println("  Parsed '" + positiveIntString + "' as double: " + intAsDouble);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + positiveIntString + "' as double.");
           }
   
            try {
               double invalidAsDouble = Double.parseDouble(invalidString);
               System.out.println("  Parsed '" + invalidString + "' as double: " + invalidAsDouble);
           } catch (NumberFormatException e) {
               System.out.println("  Could not parse '" + invalidString + "' as double.");
           }
       }
   }

   Esto es lo que está sucediendo:

   • Ahora tenemos cadenas que representan un entero positivo, un entero negativo, un número decimal y una cadena no válida.
   • Usamos Integer.parseInt() dentro de bloques try-catch para intentar analizar las cadenas como enteros. Observa que Integer.parseInt() puede manejar el signo negativo (-). Sin embargo, lanzará una NumberFormatException si la cadena contiene un punto decimal o caracteres no numéricos.
   • Usamos Double.parseDouble() dentro de bloques try-catch para intentar analizar las cadenas como números decimales (dobles). Double.parseDouble() puede manejar tanto enteros como números con puntos decimales. Lanzará una NumberFormatException para cadenas que no son representaciones válidas de un doble.

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Compila el programa en la Terminal:

   javac HelloJava.java

   No deberías ver salida si la compilación es exitosa.

5. Ejecuta el programa compilado:

   java HelloJava

   Deberías ver una salida similar a esta:

   Attempting to parse integers:
     Parsed '456' as integer: 456
     Parsed '-789' as integer: -789
     Could not parse '123.45' as integer.
   
   Attempting to parse decimal numbers:
     Parsed '123.45' as double: 123.45
     Parsed '456' as double: 456.0
     Could not parse 'not a number' as double.

   Esta salida muestra que Integer.parseInt() analizó correctamente los enteros positivos y negativos, pero falló con la cadena decimal. Double.parseDouble() analizó con éxito tanto la cadena decimal como la cadena entera (representándola como un doble, por ejemplo, 456.0), pero falló con la cadena no válida.

Este paso demuestra cómo usar los métodos de análisis adecuados para diferentes tipos de números y refuerza la importancia de usar bloques try-catch para manejar posibles errores de NumberFormatException cuando la cadena de entrada puede no estar en el formato esperado.

Resumen

En este laboratorio, aprendimos cómo comprobar si una cadena es numérica en Java. Primero exploramos el uso de Integer.parseInt() para intentar analizar una cadena en un entero, comprendiendo que este método lanza una NumberFormatException si la cadena no es una representación válida de un entero. Vimos cómo manejar esta excepción utilizando un bloque try-catch para gestionar de manera elegante las cadenas no numéricas.

A partir de esto, luego aprendimos cómo usar expresiones regulares como un enfoque más flexible para comprobar cadenas numéricas, que puede manejar varios formatos. Finalmente, ampliamos nuestro conocimiento para incluir el manejo de números negativos y decimales al determinar si una cadena representa un valor numérico.