Java: compruebe si la cadena es un número

En este tutorial, repasaremos ejemplos sobre cómo comprobar si una cadena representa un número en Java. Usaremos Core Java y Apache Commons Library, así como Regex.

Introducción

Las cadenas son una forma práctica de transmitir información y obtener información de un usuario.

En este artículo, analizaremos un par de formas comprobar si una cadena es numérica en Java, es decir, si una cadena representa un valor numérico.

Comprobar si la cadena es numérica con Core Java

Los usuarios tienden a escribir mal los valores de entrada con bastante frecuencia, por lo que los desarrolladores tienen que tomarse de la mano tanto como sea posible durante las operaciones de IO.

La forma más sencilla de comprobar si una String es un número o no es utilizando uno de los siguientes métodos integrados de Java:

  1. Entero.parseInt()
  2. Entero.valorDe()
  3. Double.parseDouble()
  4. Flotante.parseFloat()
  5. Largo.parseLargo()

Estos métodos convierten una String dada en su equivalente numérico. Si no pueden convertirlo, se lanza una NumberFormatException, lo que indica que la cadena no era numérica.

Vale la pena señalar que Integer.valueOf() devuelve un nuevo Integer(), mientras que Integer.parseInt() devuelve un int primitivo. Tenga esto en cuenta si tal diferencia cambiaría el flujo de su programa.

Probemos esto:

1
2
3
4
5
6
7
8
String string = "10";

try {
    intValue = Integer.parseInt(string);
    return true;
} catch (NumberFormatException e) {
    System.out.println("Input String cannot be parsed to Integer.");
}

Esto resulta en:

1
true

Ahora, podemos abstraer esta funcionalidad en un método auxiliar por conveniencia:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
public static boolean isNumeric(String string) {
    int intValue;
        
    System.out.println(String.format("Parsing string: \"%s\"", string));
        
    if(string == null || string.equals("")) {
        System.out.println("String cannot be parsed, it is null or empty.");
        return false;
    }
    
    try {
        intValue = Integer.parseInt(string);
        return true;
    } catch (NumberFormatException e) {
        System.out.println("Input String cannot be parsed to Integer.");
    }
    return false;
}

Ahora, simplemente podemos llamar:

1
2
3
4
5
6
7
8
String string = "10";

if(isNumeric(string)) { 
    System.out.println("String is numeric!");
    // Do something
} else {
    System.out.println("String is not numeric.");
}

Ejecutar este código daría como resultado:

1
2
Parsing string: "10"
String is numeric!

Por otro lado, si esperamos que String contenga un número realmente grande, podemos llamar al constructor BigInteger(String), que traduce la representación de String en un BigInteger.

Comprobar si la cadena es numérica con Apache Commons

Apache Commons es una de las bibliotecas de terceros más utilizadas para expandir el marco básico de Java. Nos da un control más preciso sobre las clases principales de Java, en este caso, Strings.

Veremos dos clases de la biblioteca Apache Commons:

  1. Número de utilidades
  2. StringUtils

Ambos son muy similares a sus contrapartes de la clase Vanilla Java, pero con énfasis en las operaciones null-safe (en números y cadenas respectivamente), lo que significa que incluso podemos definir valores predeterminados para valores faltantes (null).

Ahora echemos un vistazo a cómo podemos verificar valores numéricos usando estos métodos.

NumberUtils.isParsable()

Este método acepta una Cadena y verifica si es un número analizable o no, podemos usar este método en lugar de detectar una excepción al llamar a uno de los métodos que mencionamos anteriormente.

Esto es muy bueno porque las soluciones que involucran el manejo frecuente de excepciones deben evitarse si es posible; esto es exactamente con lo que nos ayuda este método.

Tenga en cuenta que los números hexadecimales y las notaciones científicas no se consideran analizables.

Ahora, realmente ni siquiera necesitamos un método auxiliar de conveniencia, ya que isParseable() devuelve un booleano en sí mismo:

1
2
3
4
5
6
7
String string = "10";

if (NumberUtils.isParsable(string)) {
    System.out.println("String is numeric!");
} else {
    System.out.println("String is not numeric.");
}

Este código debería devolver:

1
String is numeric!

NumberUtils.isCreatable()

Este método también acepta una cadena y verifica si es un número válido de Java. Con este método podemos cubrir incluso más números, porque un número válido de Java incluye incluso números hexadecimales y octales, notación científica, así como números marcados con un calificador de tipo.

Ahora, incluso podemos usar algo como:

1
2
3
4
5
6
7
String string = "0x10AB";

if (NumberUtils.isCreatable(string)) {
    System.out.println("String contains a creatable number!");
} else {
    System.out.println("String doesn't contain creatable number.");
}

La salida sería:

1
String contains a creatable number!

NumberUtils.isDigits()

El método NumberUtils.isDigits() verifica si una cadena contiene solo dígitos Unicode. Si la ‘Cadena’ contiene un signo inicial o un punto decimal, el método devolverá ‘falso’:

1
2
3
4
5
6
7
String string = "25";

if (NumberUtils.isDigits(string)) {
    System.out.println("String is numeric!");
} else {
    System.out.println("String isn't numeric.");
}

StringUtils.isNumeric()

StringUtils.isNumeric() es el equivalente StringUtils de NumberUtils.isDigits().

Si String pasa la prueba numérica, aún puede generar un error NumberFormatException cuando se analiza con los métodos que mencionamos anteriormente, por ejemplo, si está fuera del rango de int o long.

Usando este método podemos determinar si podemos analizar String en un Integer:

1
2
3
4
5
6
7
String string = "25";

if (StringUtils.isNumeric(string)) {
    System.out.println("String is numeric!");
} else {
    System.out.println("String isn't numeric.");
}

StringUtils.isNumericSpace()

Además, si esperamos encontrar más números dentro de una cadena, podemos usar isNumericSpace, otro método útil de StringUtils que vale la pena mencionar. Comprueba si la String contiene solo dígitos Unicode o espacios.

Comprobemos una cadena que contiene números y espacios:

1
2
3
4
5
6
7
String string = "25 50 15";

if (StringUtils.isNumericSpace(string)) {
    System.out.println("String is numeric!");
} else {
    System.out.println("String isn't numeric.");
}

Esto resulta en:

1
String is numeric!

Comprobar si la cadena es numérica con Regex

Aunque la mayoría de los desarrolladores se contentarán con usar un método ya implementado, a veces es posible que tenga una verificación de patrones muy específica:

1
2
3
4
5
6
7
public static boolean isNumeric(String string) {
    // Checks if the provided string
    // is a numeric by applying a regular
    // expression on it.
    String regex = "[0-9]+[\\.]?[0-9]*";
    return Pattern.matches(regex, string);
}

Y luego, podemos llamar a este método:

1
2
System.out.println("123: " + isStringNumeric2("123"));
System.out.println("I'm totally a numeric, trust me: " + isStringNumeric2("I'm totally a numeric, trust me"));

Ejecutar esto nos da el siguiente resultado:

1
2
123: true
I'm totally a numeric, trust me: false

Conclusión

En este artículo, hemos cubierto varias formas de comprobar si una cadena es numérica o no (representa un número) en Java.

Comenzamos usando Core Java y capturando una NumberFormatException, después de lo cual usamos la biblioteca Apache Commons. A partir de ahí, hemos utilizado las clases StringUtils y NumberUtils para verificar si una cadena es numérica o no, con varios formatos.