tipos - Determine si una cadena es un entero en Java

tipos de variables en java ejemplos

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cuál es la mejor manera de verificar si una cadena representa un número entero en Java? 35 respuestas

Estoy tratando de determinar si un elemento en particular en una matriz de cadenas es un número entero o no.

Estoy .split(" ")''ing una expresión de infijo en forma de String y luego tratando de dividir la matriz resultante en dos matrices; uno para enteros, uno para operadores, mientras se descartan paréntesis, y otros elementos diversos. ¿Cuál sería la mejor manera de lograr esto?

Pensé que podría encontrar un método Integer.isInteger(String arg) o algo así, pero no tanta suerte.

Answer 1

Como alternativa a intentar analizar la cadena y capturar la NumberFormatException , puede usar una expresión regular; p.ej

if (Pattern.compile("-?[0-9]+").matches(str)) {
    // its an integer
}

Es probable que esto sea más rápido, especialmente si precompila y reutiliza la expresión regular. Sin embargo, el problema es que Integer.parseInt(str) todavía fallará si str representa un número que está fuera del rango de los valores legales int .

Answer 2

Desea utilizar el método Integer.parseInt(String) .

try{
  int num = Integer.parseInt(str);
  // is an integer!
} catch (NumberFormatException e) {
  // not an integer!
}

Answer 3

La forma más ingenua sería iterar sobre la Cadena y asegurarse de que todos los elementos sean dígitos válidos para el radix dado. Esto es lo más eficiente posible, ya que debe mirar cada elemento al menos una vez. Supongo que podríamos micro-optimizarlo basado en el radix, pero para todos los efectos, esto es lo mejor que puede esperar obtener.

public static boolean isInteger(String s) {
    return isInteger(s,10);
}

public static boolean isInteger(String s, int radix) {
    if(s.isEmpty()) return false;
    for(int i = 0; i < s.length(); i++) {
        if(i == 0 && s.charAt(i) == ''-'') {
            if(s.length() == 1) return false;
            else continue;
        }
        if(Character.digit(s.charAt(i),radix) < 0) return false;
    }
    return true;
}

Alternativamente, puede confiar en la biblioteca de Java para tener esto. No se basa en excepciones y detectará casi todas las condiciones de error que pueda imaginar. Será un poco más caro (tiene que crear un objeto de escáner, que en un bucle muy crítico que no quiere hacer. Pero, en general, no debería ser mucho más caro, así que para el día a día Las operaciones deben ser bastante fiables.

public static boolean isInteger(String s, int radix) {
    Scanner sc = new Scanner(s.trim());
    if(!sc.hasNextInt(radix)) return false;
    // we know it starts with a valid int, now make sure
    // there''s nothing left!
    sc.nextInt(radix);
    return !sc.hasNext();
}

Si las mejores prácticas no son importantes para usted, o si desea rastrear a la persona que hace las revisiones de su código, intente con esto:

public static boolean isInteger(String s) {
    try { 
        Integer.parseInt(s); 
    } catch(NumberFormatException e) { 
        return false; 
    } catch(NullPointerException e) {
        return false;
    }
    // only got here if we didn''t return false
    return true;
}

Answer 4

O puede solicitar un poco de ayuda de nuestros buenos amigos en Apache Commons: StringUtils.isNumeric (String str)

Answer 5

O simplemente

mystring.matches("//d+")

aunque devolvería cierto para números más grandes que un int.

Answer 6

Puede usar Integer.parseInt() o Integer.valueOf() para obtener el entero de la cadena y capturar la excepción si no es un int. Analizable. Desea asegurarse de capturar la NumberFormatException que puede lanzar.

Puede ser útil tener en cuenta que valueOf () devolverá un objeto Integer, no el int primitivo.

Answer 7

Puede usar Integer.parseInt(str) y capturar la NumberFormatException si la cadena no es un entero válido, de la siguiente manera (como lo indican todas las respuestas):

static boolean isInt(String s)
{
 try
  { int i = Integer.parseInt(s); return true; }

 catch(NumberFormatException er)
  { return false; }
}

Sin embargo, tenga en cuenta que si el entero evaluado se desborda, se lanzará la misma excepción. Su propósito era averiguar si era un número entero válido o no. Así que es más seguro hacer su propio método para verificar la validez:

static boolean isInt(String s)  // assuming integer is in decimal number system
{
 for(int a=0;a<s.length();a++)
 {
    if(a==0 && s.charAt(a) == ''-'') continue;
    if( !Character.isDigit(s.charAt(a)) ) return false;
 }
 return true;
}

Answer 8

Usar la expresión regular es mejor

str.matches("-?//d+");


-?     --> negative sign, could have none or one
//d+   --> one or more digits

No es bueno usar NumberFormatException aquí si puede usar if-statement lugar.

Si no quiere encabezar cero, puede usar la expresión regular de la siguiente manera:

str.matches("-?(0|[1-9]//d*)");

Answer 9

public boolean isInt(String str){
    return (str.lastIndexOf("-") == 0 && !str.equals("-0")) ? str.substring(1).matches(
            "//d+") : str.matches("//d+");
}