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

Cela se fait généralement avec une simple fonction définie par l'utilisateur (c'est à dire Rouler "isNumeric" de la fonction).

Quelque chose comme:

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

Toutefois, si vous êtes à l'appel de cette fonction beaucoup, et vous vous attendez à de nombreux contrôles à l'échec en raison de ne pas être un numéro, puis les performances de ce mécanisme ne sera pas grande, puisque vous êtes s'appuyer sur l'exception levée pour chaque échec, ce qui est relativement coûteuse opération.

Une approche alternative peut être d'utiliser une expression régulière pour vérifier la validité d'un numéro:

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

Être prudent avec les RegEx mécanisme, bien que, comme il va échouer si vous utilisez la non-chiffres arabes (c'est à dire de chiffres autres qu'0 à 9). C'est parce que le "\d" une partie de la RegEx ne match [0-9] et efficace n'est pas à l'échelle internationale numériquement au courant. (Merci à OregonGhost pour le signaler!)

Ou même une autre alternative est d'utiliser Java intégré dans java.texte.NumberFormat objet pour voir si, après l'analyse de la chaîne de l'analyseur est la position à la fin de la chaîne. Si elle l'est, nous pouvons présumer que l'ensemble de la chaîne numérique:

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

Comme @CraigTP l'avait mentionné dans son excellente réponse, j'ai également avoir des problèmes de performances sur l'utilisation d'Exceptions pour vérifier si la chaîne est numérique ou pas. Donc je me retrouve fractionnement de la chaîne et de l'utilisation 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) correctement reconnaît non latine chiffres. En terme de Performance, je pense qu'un simple N nombre de comparaisons où N est le nombre de caractères dans la chaîne seraient plus efficaces de calcul que de faire une regex de correspondance.

Mise à JOUR: Comme indiqué par Jean-François Corbett dans le commentaire, le code ci-dessus serait seulement de valider les entiers positifs, qui couvre la majorité de mon cas d'utilisation. Ci-dessous la mise à jour du code qui valide correctement les nombres décimaux selon les paramètres régionaux par défaut utilisée dans votre système, avec l'hypothèse que le séparateur décimal ne se produisent une 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;
}

Google Goyave bibliothèque fournit une bonne méthode d'assistance pour ce faire: Ints.tryParse. Vous l'utilisez comme une Integer.parseInt mais il renvoie null plutôt que de lever une Exception si la chaîne de ne pas analyser à un entier valide. Notez qu'il retourne Entier, et non pas de type int, donc vous devez le convertir/autobox de retour à l'int.

Exemple:

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, la version actuelle -- Goyave r11 -- elle est encore marquée @Bêta.

Je n'ai pas comparé ça. En regardant le code source il y a une surcharge de beaucoup de vérifications, mais à la fin ils utilisent Character.digit(string.charAt(idx)), similaire, mais légèrement différente de la réponse de @Ibrahim ci-dessus. Il n'y a pas de gestion des exceptions la surcharge sous les couvertures dans leur mise en œuvre.

Pourquoi tout le monde en poussant d'exception/regex solutions?

Même si je peux comprendre la plupart des gens sont beaux, avec l'aide de try/catch, si vous voulez le faire souvent... il peut être extrêmement pénible.

Ce que j'ai fait ici est de prendre la regex, le parseNumber() les méthodes, et la matrice de méthode de recherche afin de voir laquelle est la plus efficace. Cette fois, j'ai seulement regardé des nombres entiers.

public static boolean isNumericRegex(String str) {
    if (str == null)
        return false;
    return str.matches("-?\\d+");
}

public static boolean isNumericArray(String str) {
    if (str == null)
        return false;
    char[] data = str.toCharArray();
    if (data.length <= 0)
        return false;
    int index = 0;
    if (data[0] == '-' && data.length > 1)
        index = 1;
    for (; index < data.length; index++) {
        if (data[index] < '0' || data[index] > '9') //Character.isDigit() can go here too.
            return false;
    }
    return true;
}

public static boolean isNumericException(String str) {
    if (str == null)
        return false;
    try {  
        /* int i = */ Integer.parseInt(str);
    } catch (NumberFormatException nfe) {  
        return false;  
    }
    return true;
}

Les résultats de la vitesse que j'ai sont:

Done with: for (int i = 0; i < 10000000; i++)...

With only valid numbers ("59815833" and "-59815833"):
    Array numeric took 395.808192 ms [39.5808192 ns each]
    Regex took 2609.262595 ms [260.9262595 ns each]
    Exception numeric took 428.050207 ms [42.8050207 ns each]
    //Negative sign
    Array numeric took 355.788273 ms [35.5788273 ns each]
    Regex took 2746.278466 ms [274.6278466 ns each]
    Exception numeric took 518.989902 ms [51.8989902 ns each]
    //Single value ("1")
    Array numeric took 317.861267 ms [31.7861267 ns each]
    Regex took 2505.313201 ms [250.5313201 ns each]
    Exception numeric took 239.956955 ms [23.9956955 ns each]
    //With Character.isDigit()
    Array numeric took 400.734616 ms [40.0734616 ns each]
    Regex took 2663.052417 ms [266.3052417 ns each]
    Exception numeric took 401.235906 ms [40.1235906 ns each]

With invalid characters ("5981a5833" and "a"):
    Array numeric took 343.205793 ms [34.3205793 ns each]
    Regex took 2608.739933 ms [260.8739933 ns each]
    Exception numeric took 7317.201775 ms [731.7201775 ns each]
    //With a single character ("a")
    Array numeric took 291.695519 ms [29.1695519 ns each]
    Regex took 2287.25378 ms [228.725378 ns each]
    Exception numeric took 7095.969481 ms [709.5969481 ns each]

With null:
    Array numeric took 214.663834 ms [21.4663834 ns each]
    Regex took 201.395992 ms [20.1395992 ns each]
    Exception numeric took 233.049327 ms [23.3049327 ns each]
    Exception numeric took 6603.669427 ms [660.3669427 ns each] if there is no if/null check

Avertissement: je ne dis pas que ces méthodes sont 100% optimisé, ils sont juste là pour la démonstration de données

Exceptions gagné si et seulement si le nombre est de 4 caractères ou moins, et chaque chaîne est toujours un certain nombre... dans ce cas, pourquoi ont même un chèque?

En bref, c'est extrêmement douloureux si vous exécutez dans les numéros non valides fréquemment avec le try/catch, qui fait sens. Une règle importante, j'ai toujours suivre est ne JAMAIS utiliser try/catch pour le flux de programme. Ceci est un exemple de pourquoi.

Fait intéressant, le plus simple si char <0 || >9 est extrêmement simple à écrire, facile à retenir (et doit travailler dans plusieurs langues) et gagne presque tous les scénarios de test.

Le seul inconvénient est que je devine Entier.parseInt() peut-poignée non ASCII des chiffres, alors que le tableau de méthode de recherche ne fonctionne pas.

---

Pour ceux qui se demandent pourquoi j'ai dit que c'est facile de se rappeler le tableau de caractères, si vous le savez il n'y a pas de signes négatifs, vous pouvez facilement obtenir loin avec quelque chose de résumés comme ceci:

public static boolean isNumericArray(String str) {
    if (str == null)
        return false;
    for (char c : str.toCharArray())
        if (c < '0' || c > '9')
            return false;
    return true;

---

Enfin comme note finale, j'étais curieux de connaître l'affectation de l'opérateur dans l'acceptation exemple avec tous les votes jusqu'. L'ajout de la cession de l'

double d = Double.parseDouble(...)

n'est pas seulement inutile, puisque vous n'avez même pas utiliser la valeur, mais il gaspille du temps de traitement et l'augmentation de l'exécution de quelques nanosecondes (qui a conduit à une 100-200 ms augmentation dans les tests). Je ne vois pas pourquoi quelqu'un voudrait le faire car c'est réellement un travail supplémentaire pour réduire les performances.

Vous pensez que ce serait optimisé à... mais je devrais peut-être vérifier le pseudo-code et voir ce que le compilateur est en train de faire. Cela n'explique pas pourquoi il a toujours montré comme plus long pour moi mais si de toute façon il est optimisé pour sortir... donc je me demande ce qu'il se passe. Comme une note: En plus long, je veux dire l'exécution de l'essai pour 10000000 itérations, et l'exécution de ce programme plusieurs fois (10x+) toujours montré pour être plus lent.

EDIT: mise à Jour d'un test de Caractère.appel isdigit()

Vous pouvez utiliser NumberFormat#parse:

try
{
     NumberFormat.getInstance().parse(value);
}
catch(ParseException e)
{
    //Not a number.
}

Si vous utiliser java pour développer des applications Android, vous pouvez à l'aide de TextUtils.isDigitsOnly fonction.

Pour correspondre seul point positif de base dix entiers, qui ne contient que des caractères ASCII, utilisez:

public static boolean isNumeric(String maybeNumeric) {
return maybeNumeric != null && maybeNumeric.matches("[0-9]+");
}

Voici ma classe pour vérifier si une chaîne de caractères numériques. Il fixe également des chaînes numériques:

Caractéristiques:

1. Supprime les zéros inutiles ["12.0000000" -> "12"]
2. Supprime les zéros inutiles ["12.0580000" -> "12.058"]
3. Supprime non des caractères numériques ["12.00sdfsdf00" -> "12"]
4. Poignées négatif de la chaîne de valeurs ["-12,020000" -> "-12.02"]
5. Supprime plusieurs points ["-12.0.20.000" -> "-12.02"]
6. Pas de bibliothèques supplémentaires, juste Java standard

Ici vous allez...

public class NumUtils {
/**
* Transforms a string to an integer. If no numerical chars returns a String "0".
*
* @param str
* @return retStr
*/
static String makeToInteger(String str) {
String s = str;
double d;
d = Double.parseDouble(makeToDouble(s));
int i = (int) (d + 0.5D);
String retStr = String.valueOf(i);
System.out.printf(retStr + "   ");
return retStr;
}
/**
* Transforms a string to an double. If no numerical chars returns a String "0".
*
* @param str
* @return retStr
*/
static String makeToDouble(String str) {
Boolean dotWasFound = false;
String orgStr = str;
String retStr;
int firstDotPos = 0;
Boolean negative = false;
//check if str is null
if(str.length()==0){
str="0";
}
//check if first sign is "-"
if (str.charAt(0) == '-') {
negative = true;
}
//check if str containg any number or else set the string to '0'
if (!str.matches(".*\\d+.*")) {
str = "0";
}
//Replace ',' with '.'  (for some european users who use the ',' as decimal separator)
str = str.replaceAll(",", ".");
str = str.replaceAll("[^\\d.]", "");
//Removes the any second dots
for (int i_char = 0; i_char < str.length(); i_char++) {
if (str.charAt(i_char) == '.') {
dotWasFound = true;
firstDotPos = i_char;
break;
}
}
if (dotWasFound) {
String befDot = str.substring(0, firstDotPos + 1);
String aftDot = str.substring(firstDotPos + 1, str.length());
aftDot = aftDot.replaceAll("\\.", "");
str = befDot + aftDot;
}
//Removes zeros from the begining
double uglyMethod = Double.parseDouble(str);
str = String.valueOf(uglyMethod);
//Removes the .0
str = str.replaceAll("([0-9])\\.0+([^0-9]|$)", "$1$2");
retStr = str;
if (negative) {
retStr = "-"+retStr;
}
return retStr;
}
static boolean isNumeric(String str) {
try {
double d = Double.parseDouble(str);
} catch (NumberFormatException nfe) {
return false;
}
return true;
}
}

Exceptions sont chers, mais dans ce cas, la RegEx prend beaucoup plus de temps. Le code ci-dessous montre un simple test de deux fonctions, l'une à l'aide d'exceptions et une à l'aide de regex. Sur ma machine la RegEx version est 10 fois plus lent que l'exception.

import java.util.Date;
public class IsNumeric {
public static boolean isNumericOne(String s) {
return s.matches("-?\\d+(\\.\\d+)?");  //match a number with optional '-' and decimal.      
}
public static boolean isNumericTwo(String s) {
try {
Double.parseDouble(s);
return true;
} catch (Exception e) {
return false;
}
}
public static void main(String [] args) {
String test = "12345.F";
long before = new Date().getTime();     
for(int x=0;x<1000000;++x) {
//isNumericTwo(test);
isNumericOne(test);
}
long after = new Date().getTime();
System.out.println(after-before);
}
}

//only int
public static boolean isNumber(int num) 
{
return (num >= 48 && c <= 57); //0 - 9
}
//is type of number including . - e E 
public static boolean isNumber(String s) 
{
boolean isNumber = true;
for(int i = 0; i < s.length() && isNumber; i++) 
{
char c = s.charAt(i);
isNumber = isNumber & (
(c >= '0' && c <= '9') || (c == '.') || (c == 'e') || (c == 'E') || (c == '')
);
}
return isInteger;
}
//is type of number 
public static boolean isInteger(String s) 
{
boolean isInteger = true;
for(int i = 0; i < s.length() && isInteger; i++) 
{
char c = s.charAt(i);
isInteger = isInteger & ((c >= '0' && c <= '9'));
}
return isInteger;
}
public static boolean isNumeric(String s) 
{
try
{
Double.parseDouble(s);
return true;
}
catch (Exception e) 
{
return false;
}
}

Vous pouvez utiliser le java.util.Scanner objet.

public static boolean isNumeric(String inputData) {
Scanner sc = new Scanner(inputData);
return sc.hasNextInt();
}

C'est pourquoi j'aime l'Essayer* approche .NET. En plus de la traditionnelle méthode d'analyse qui est comme le code Java, vous avez également une méthode TryParse. Je ne suis pas bon dans la syntaxe Java (paramètres de sortie?), donc, veuillez considérer ce qui suit comme une sorte de pseudo-code. Il devrait rendre le concept plus clair.

boolean parseInteger(String s, out int number)
{
try {
number = Integer.parseInt(myString);
return true;
} catch(NumberFormatException e) {
return false;
}
}

Utilisation:

int num;
if (parseInteger("23", out num)) {
//Do something with num.
}

Vous pouvez utiliser NumberUtils.isCreatable() à partir de Apache Commons Lang.

Depuis NumberUtils.isNumber sera obsolète dans la version 4.0, afin de l'utiliser NumberUtils.isCreatable() à la place.

J'ai illustré certaines conditions à vérifier les chiffres et de décimales sans l'aide d'une API,

Vérifier la Correction de Longueur 1 chiffres

Character.isDigit(char)

Vérifier la Correction de Longueur (numéro d'Assumer la longueur est de 6)

String number = "132452";
if(number.matches("([0-9]{6})"))
System.out.println("6 digits number identified");

Case à Longueur Variable nombre entre (à Supposer de 4 à 6 longueur)

// {n,m}  n <= length <= m
String number = "132452";
if(number.matches("([0-9]{4,6})"))
System.out.println("Number Identified between 4 to 6 length");
String number = "132";
if(!number.matches("([0-9]{4,6})"))
System.out.println("Number not in length range or different format");

Case à Longueur Variable nombre décimal entre (à Supposer de 4 à 7 longueur)

// It will not count the '.' (Period) in length
String decimal = "132.45";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "1.12";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "1234";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "-10.123";
if(decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Numbers Identified between 4 to 7");
String decimal = "123..4";
if(!decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Decimal not in range or different format");
String decimal = "132";
if(!decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Decimal not in range or different format");
String decimal = "1.1";
if(!decimal.matches("(-?[0-9]+(\.)?[0-9]*){4,6}"))
System.out.println("Decimal not in range or different format");

Espère que ça aidera manyone.

Voici deux méthodes qui pourraient travailler. (Sans l'aide d'Exceptions).
Remarque : Java est un passe-par-valeur par défaut et d'une Chaîne de valeur est l'adresse de la Chaîne de l'objet de données.
Donc , quand vous faites

stringNumber = stringNumber.replaceAll(" ", "");

Vous avez modifié la valeur d'entrée n'ont pas d'espaces.
Vous pouvez supprimer cette ligne si vous le souhaitez.

private boolean isValidStringNumber(String stringNumber)
{
if(stringNumber.isEmpty())
{
return false;
}
stringNumber = stringNumber.replaceAll(" ", "");
char [] charNumber = stringNumber.toCharArray();
for(int i =0 ; i<charNumber.length ;i++)
{
if(!Character.isDigit(charNumber[i]))
{
return false;
}
}
return true;
}

Voici une autre méthode dans le cas où vous souhaitez autoriser les flotteurs
Cette méthode prétendument permet aux nombres sous forme de pass
1,123,123,123,123,123.123
je viens de faire , et je pense qu'il a besoin de plus de tests pour s'assurer qu'il fonctionne.

private boolean isValidStringTrueNumber(String stringNumber)
{
if(stringNumber.isEmpty())
{
return false;
}
stringNumber = stringNumber.replaceAll(" ", "");
int countOfDecimalPoint = 0;
boolean decimalPointPassed = false;
boolean commaFound = false;
int countOfDigitsBeforeDecimalPoint = 0;
int countOfDigitsAfterDecimalPoint =0 ;
int commaCounter=0;
int countOfDigitsBeforeFirstComma = 0;
char [] charNumber = stringNumber.toCharArray();
for(int i =0 ; i<charNumber.length ;i++)
{
if((commaCounter>3)||(commaCounter<0))
{
return false;
}
if(!Character.isDigit(charNumber[i]))//Char is not a digit.
{
if(charNumber[i]==',')
{
if(decimalPointPassed)
{
return false;
}
commaFound = true;
//check that next three chars are only digits.
commaCounter +=3;
}
else if(charNumber[i]=='.')
{
decimalPointPassed = true;
countOfDecimalPoint++;
}
else
{
return false;
}
}
else //Char is a digit.
{
if ((commaCounter>=0)&&(commaFound))
{
if(!decimalPointPassed)
{
commaCounter--;
}
}
if(!commaFound)
{
countOfDigitsBeforeFirstComma++;
}
if(!decimalPointPassed)
{
countOfDigitsBeforeDecimalPoint++;
}
else
{
countOfDigitsAfterDecimalPoint++;
}
}
}
if((commaFound)&&(countOfDigitsBeforeFirstComma>3))
{
return false;
}
if(countOfDecimalPoint>1)
{
return false;
}
if((decimalPointPassed)&&((countOfDigitsBeforeDecimalPoint==0)||(countOfDigitsAfterDecimalPoint==0)))
{
return false;
}
return true;
}

C'est le plus rapide que je connaisse pour vérifier si la Chaîne est le Nombre ou pas:

public static boolean isNumber(String str){
int i=0, len=str.length();
boolean a=false,b=false,c=false, d=false;
if(i<len && (str.charAt(i)=='+' || str.charAt(i)=='-')) i++;
while( i<len && isDigit(str.charAt(i)) ){ i++; a=true; }
if(i<len && (str.charAt(i)=='.')) i++;
while( i<len && isDigit(str.charAt(i)) ){ i++; b=true; }
if(i<len && (str.charAt(i)=='e' || str.charAt(i)=='E') && (a || b)){ i++; c=true; }
if(i<len && (str.charAt(i)=='+' || str.charAt(i)=='-') && c) i++;
while( i<len && isDigit(str.charAt(i)) ){ i++; d=true;}
return i==len && (a||b) && (!c || (c && d));
}
static boolean isDigit(char c){
return c=='0' || c=='1' || c=='2' || c=='3' || c=='4' || c=='5' || c=='6' || c=='7' || c=='8' || c=='9';
}

Les gars si vous utilisez la méthode suivante pour vérifier:

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

Puis ce qui s'est vraiment passé avec l'entrée de Chaîne très longue, comme je l'ai appeler cette méthode:

System.out.println(isNumeric("94328948243242352525243242524243425452342343948923"));

Le résultat est "vrai", il est aussi un trop grand nombre de taille!
La même chose se produira si vous en utilisant les regex pour vérifier!
Donc, je préfère utiliser le "parsing" méthode pour vérifier, comme ceci:

public static boolean isNumeric(String str) {
try {
int number = Integer.parseInt(str);
return true;
} catch (Exception e) {
return false;
}
}

Et le résultat est ce que j'attendais!

Si vous voulez faire la vérification à l'aide d'une regex vous devez créer un Modèle statique de l'objet, de sorte que la regex n'a besoin d'être compilé une fois. La compilation de la regex faut autant de temps que l'exécution du match en prenant cette précaution, vous réduisez le temps d'exécution de la méthode dans la moitié.

final static Pattern NUMBER_PATTERN = Pattern.compile("[+-]?\\d*\\.?\\d+");
static boolean isNumber(String input) {
Matcher m = NUMBER_PATTERN.matcher(input);
return m.matches();
}

Je suis en supposant un nombre est une chaîne de caractères avec rien, mais les chiffres décimaux, y a + ou le signe - au début et à la plupart un point décimal (pas à la fin) et pas d'autres caractères (y compris les virgules, les espaces, les chiffres dans d'autres systèmes de comptage, des chiffres Romains, des hiéroglyphes).

Cette solution est succincte et assez vite, mais vous permet de vous raser quelques millisecondes par million d'invocations en faisant comme ceci

static boolean isNumber(String s) {
final int len = s.length();
if (len == 0) {
return false;
}
int dotCount = 0;
for (int i = 0; i < len; i++) {
char c = s.charAt(i);
if (c < '0' || c > '9') {
if (i == len - 1) {//last character must be digit
return false;
} else if (c == '.') {
if (++dotCount > 1) {
return false;
}
} else if (i != 0 || c != '+' && c != '-') {//+ or - allowed at start
return false;
}
}
}
return true;
}

String text="hello 123";
if(Pattern.matches([0-9]+))==true
System.out.println("String"+text);