Comment vérifier si une chaîne est numérique en Java ?

Question

Comment vérifier si une chaîne est un nombre avant de l'analyser ?

Answer 1

Cela se fait généralement à l'aide d'une simple fonction définie par l'utilisateur (par exemple, la fonction "isNumeric" de Roll-your-own).

Quelque chose comme :

public static boolean isNumeric(String str) { 
  try {  
    Double.parseDouble(str);  
    return true;
  } catch(NumberFormatException e){  
    return false;  
  }  
}

Cependant, si vous appelez souvent cette fonction et que vous vous attendez à ce que de nombreuses vérifications échouent parce qu'il ne s'agit pas d'un nombre, les performances de ce mécanisme ne seront pas excellentes, puisque vous comptez sur la levée d'exceptions pour chaque échec, ce qui est une opération assez coûteuse.

Une autre approche peut consister à utiliser une expression régulière pour vérifier la validité d'un nombre :

public static boolean isNumeric(String str) {
  return str.matches("-?\\d+(\\.\\d+)?");  //match a number with optional '-' and decimal.
}

Soyez prudent avec le mécanisme RegEx ci-dessus, car il échouera si vous utilisez des chiffres non arabes (c'est-à-dire des chiffres autres que 0 à 9). Cela est dû au fait que la balise " \d La partie "RegEx" ne correspondra qu'à [0-9] et ne tient pas compte de la dimension numérique internationale. (Merci à OregonGhost de nous l'avoir signalé !)

Une autre alternative consiste à utiliser l'objet java.text.NumberFormat intégré à Java pour voir si, après l'analyse de la chaîne, la position de l'analyseur se trouve à la fin de la chaîne. Si c'est le cas, nous pouvons supposer que la chaîne entière est numérique :

public static boolean isNumeric(String str) {
  ParsePosition pos = new ParsePosition(0);
  NumberFormat.getInstance().parse(str, pos);
  return str.length() == pos.getIndex();
}

Answer 2

Avec Langage Apache Commons 3,5 et plus : NumberUtils.isCreatable o StringUtils.isNumeric .

Avec Langage Apache Commons 3.4 et moins : NumberUtils.isNumber o StringUtils.isNumeric .

Vous pouvez également utiliser StringUtils.isNumericSpace qui renvoie true pour les chaînes vides et ignore les espaces internes de la chaîne. Une autre façon de procéder est d'utiliser NumberUtils.isParsable qui vérifie essentiellement que le nombre est analysable selon Java. (Les javadocs liées contiennent des exemples détaillés pour chaque méthode).

Answer 3

Si vous êtes sur Android, alors vous devriez utiliser :

android.text.TextUtils.isDigitsOnly(CharSequence str)

La documentation peut être trouvée ici

rester simple . la plupart des gens peuvent "reprogrammer" (la même chose).

Answer 4

Comme @CraigTP l'avait mentionné dans son excellente réponse, j'ai également des problèmes de performance similaires en utilisant des exceptions pour tester si la chaîne est numérique ou non. Je finis donc par diviser la chaîne et utiliser java.lang.Character.isDigit() .

public static boolean isNumeric(String str)
{
    for (char c : str.toCharArray())
    {
        if (!Character.isDigit(c)) return false;
    }
    return true;
}

Selon la Javadoc , Character.isDigit(char) reconnaîtra correctement les chiffres non latins. Du point de vue des performances, je pense qu'un simple nombre N de comparaisons, où N est le nombre de caractères de la chaîne, serait plus efficace que de faire une correspondance avec une regex.

MISE À JOUR : Comme l'a fait remarquer Jean-François Corbett dans le commentaire, le code ci-dessus ne validerait que les nombres entiers positifs, ce qui couvre la majorité de mon cas d'utilisation. Voici le code mis à jour qui valide correctement les nombres décimaux selon la locale par défaut utilisée dans votre système, en supposant que le séparateur décimal n'apparaît qu'une seule fois dans la chaîne.

public static boolean isStringNumeric( String str )
{
    DecimalFormatSymbols currentLocaleSymbols = DecimalFormatSymbols.getInstance();
    char localeMinusSign = currentLocaleSymbols.getMinusSign();

    if ( !Character.isDigit( str.charAt( 0 ) ) && str.charAt( 0 ) != localeMinusSign ) return false;

    boolean isDecimalSeparatorFound = false;
    char localeDecimalSeparator = currentLocaleSymbols.getDecimalSeparator();

    for ( char c : str.substring( 1 ).toCharArray() )
    {
        if ( !Character.isDigit( c ) )
        {
            if ( c == localeDecimalSeparator && !isDecimalSeparatorFound )
            {
                isDecimalSeparatorFound = true;
                continue;
            }
            return false;
        }
    }
    return true;
}

Answer 5

La bibliothèque Guava de Google fournit une méthode d'aide intéressante pour ce faire : Ints.tryParse . Vous l'utilisez comme Integer.parseInt mais il renvoie null plutôt que de lever une exception si la chaîne n'est pas convertie en un nombre entier valide. Notez qu'il renvoie Integer, et non int, donc vous devez le convertir/autoboxer en int.

Ejemplo:

String s1 = "22";
String s2 = "22.2";
Integer oInt1 = Ints.tryParse(s1);
Integer oInt2 = Ints.tryParse(s2);

int i1 = -1;
if (oInt1 != null) {
    i1 = oInt1.intValue();
}
int i2 = -1;
if (oInt2 != null) {
    i2 = oInt2.intValue();
}

System.out.println(i1);  // prints 22
System.out.println(i2);  // prints -1

Cependant, à partir de la version actuelle -- Guava r11 -- il est toujours marqué @Beta.

Je ne l'ai pas testé. En regardant le code source, il y a une certaine surcharge due à de nombreux contrôles d'intégrité, mais en fin de compte ils utilisent Character.digit(string.charAt(idx)) La réponse de @Ibrahim, similaire, mais légèrement différente, à la réponse de @Ibrahim ci-dessus. Il n'y a pas de surcharge de traitement des exceptions dans leur mise en œuvre.