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

Comment vérifieriez-vous si une chaîne était un nombre avant de l’parsingr?

Avec Apache Commons Lang 3.5 et supérieur: NumberUtils.isCreatable ou SsortingngUtils.isNumeric .

Avec Apache Commons Lang 3.4 et NumberUtils.isNumber : NumberUtils.isNumber ou SsortingngUtils.isNumeric .

Vous pouvez également utiliser SsortingngUtils.isNumericSpace qui renvoie true pour les chaînes vides et ignore les espaces internes de la chaîne. (Les javadocs liés contiennent des exemples détaillés pour chaque méthode.)

Cela se fait généralement avec une simple fonction définie par l’utilisateur (c.-à-d. La fonction “isNumeric” de Roll-your-own).

Quelque chose comme:

 public static boolean isNumeric(Ssortingng str) { try { double d = Double.parseDouble(str); } catch(NumberFormatException nfe) { return false; } return true; } 

Cependant, si vous appelez beaucoup cette fonction et que vous vous attendez à ce que beaucoup de vérifications échouent à cause du fait que ce ne soit pas un nombre, les performances de ce mécanisme ne seront pas excellentes, car vous comptez sur des 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(Ssortingng 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.-à-d. Des chiffres autres que 0 à 9). Cela est dû au fait que la partie “\ d” de RegEx ne correspondra qu’à [0-9] et ne sera effectivement pas reconnue au niveau international. (Merci à OregonGhost de l’avoir signalé!)

Ou même une autre alternative consiste à utiliser l’object java.text.NumberFormat intégré de Java pour voir si, après l’parsing de la chaîne, la position de l’parsingur est à la fin de la chaîne. Si c’est le cas, on peut supposer que la chaîne entière est numérique:

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

Si vous êtes sur Android, vous devez utiliser:

 android.text.TextUtils.isDigitsOnly(CharSequence str) 

la documentation peut être trouvée ici

rest simple la plupart du temps, tout le monde peut “re-programmer” (la même chose).

Comme @CraigTP a mentionné dans son excellente réponse, j’ai également des problèmes de performances similaires en utilisant les exceptions pour vérifier 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(Ssortingng str) { for (char c : str.toCharArray()) { if (!Character.isDigit(c)) return false; } return true; } 

Selon le Javadoc , Character.isDigit(char) reconnaîtra correctement les chiffres non latins. Du sharepoint 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 sur le plan des calculs que la comparaison avec une expression rationnelle.

MISE À JOUR: Comme l’a souligné Jean-François Corbett dans le commentaire, le code ci-dessus ne validerait que les entiers positifs, qui couvrent la majorité de mes cas d’utilisation. Vous trouverez ci-dessous le code mis à jour qui valide correctement les nombres décimaux en fonction des parameters régionaux par défaut utilisés dans votre système, en supposant que le séparateur décimal ne se produit qu’une fois dans la chaîne.

 public static boolean isSsortingngNumeric( Ssortingng 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.subssortingng( 1 ).toCharArray() ) { if ( !Character.isDigit( c ) ) { if ( c == localeDecimalSeparator && !isDecimalSeparatorFound ) { isDecimalSeparatorFound = true; continue; } return false; } } return true; } 

Expressions Java 8 lambda.

 Ssortingng someSsortingng = "123123"; boolean isNumeric = someSsortingng.chars().allMatch( Character::isDigit ); 

La bibliothèque Guava de Google fournit une méthode d’aide très Ints.tryParse pour ce faire: Ints.tryParse . Vous l’utilisez comme Integer.parseInt mais il retourne null plutôt que de lancer une exception si la chaîne n’parsing pas un entier valide. Notez qu’il retourne Integer, pas int, vous devez donc le convertir en /.

Exemple:

 Ssortingng s1 = "22"; Ssortingng 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 évalué. En regardant le code source, il y a une partie de la vérification de la santé mentale mais à la fin, ils utilisent Character.digit(ssortingng.charAt(idx)) , similaire, mais légèrement différent de la réponse de @Ibrahim ci-dessus. Il n’y a pas de traitement des exceptions sous les couvertures dans leur mise en œuvre.

N’utilisez pas les exceptions pour valider vos valeurs. Utilisez plutôt les bibliothèques Util comme apache NumberUtils:

 NumberUtils.isNumber(mySsortingngValue); 

Modifier :

Veuillez noter que si votre chaîne commence par 0, NumberUtils interprétera votre valeur comme hexadécimale.

 NumberUtils.isNumber("07") //true NumberUtils.isNumber("08") //false 

Pourquoi tout le monde pousse-t-il vers des solutions d’exception / regex?

Bien que je puisse comprendre que la plupart des gens se débrouillent bien avec l’utilisation de try / catch, si vous voulez le faire fréquemment … cela peut être extrêmement pénible.

Ce que j’ai fait ici, c’est prendre la regex, les méthodes parseNumber () et la méthode de recherche de tableaux pour voir laquelle était la plus efficace. Cette fois, j’ai seulement regardé des nombres entiers.

 public static boolean isNumericRegex(Ssortingng str) { if (str == null) return false; return str.matches("-?\\d+"); } public static boolean isNumericArray(Ssortingng 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(Ssortingng str) { if (str == null) return false; try { /* int i = */ Integer.parseInt(str); } catch (NumberFormatException nfe) { return false; } return true; } 

Les résultats en vitesse que j’ai eu étaient:

 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 

Disclaimer: Je ne prétends pas que ces méthodes sont optimisées à 100%, mais uniquement pour la démonstration des données

Les exceptions gagnées si et seulement si le nombre est de 4 caractères ou moins, et chaque chaîne est toujours un nombre ... Dans ce cas, pourquoi même avoir un chèque?

En bref, il est extrêmement douloureux de rencontrer fréquemment des nombres invalides avec la fonction try / catch, ce qui est logique. Une règle importante que je suis toujours à suivre est de ne jamais utiliser try / catch pour le déroulement du programme . Ceci est un exemple pourquoi.

Fait intéressant, le simple if char <0 || > 9 était extrêmement simple à écrire, facile à mémoriser (et devrait fonctionner dans plusieurs langues) et remporte presque tous les scénarios de test.

Le seul inconvénient est que je devine que Integer.parseInt () pourrait gérer des nombres non-ASCII, contrairement à la méthode de recherche par tableau.


Pour ceux qui se demandent pourquoi j'ai dit qu'il est facile de se rappeler le tableau de caractères, si vous savez qu'il n'y a pas de signes négatifs, vous pouvez facilement vous en passer:

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

Enfin, en guise de dernière remarque, j'étais curieux de connaître l'opérateur de l'assignation dans l'exemple accepté avec tous les votes. Ajout dans l'affectation de

 double d = Double.parseDouble(...) 

n'est pas seulement inutile puisque vous n'utilisez même pas la valeur, mais cela gaspille du temps de traitement et augmente le temps d'exécution de quelques nanosecondes (ce qui a entraîné une augmentation de 100 à 200 ms des tests). Je ne vois pas pourquoi quiconque ferait cela car il s'agit en fait d'un travail supplémentaire pour réduire les performances.

Vous penseriez que cela serait optimisé ... bien que je devrais peut-être vérifier le bytecode et voir ce que fait le compilateur. Cela n'explique pas pourquoi cela a toujours été plus long pour moi, même si, d'une manière ou d'une autre, il est optimisé, je me demande ce qui se passe. En guise de note: Plus long, je veux dire exécuter le test pour des itérations de 10000000, et exécuter ce programme plusieurs fois (10x +) a toujours montré qu'il était plus lent.

EDIT: Mise à jour d'un test pour Character.isDigit ()

 public static boolean isNumeric(Ssortingng str) { return str.matches("-?\\d+(.\\d+)?"); } 

L’expression régulière de CraigTP (ci-dessus) produit des faux positifs. Par exemple, “23y4” sera considéré comme un nombre parce que “.” correspond à n’importe quel caractère et non au point décimal.

En outre, il rejettera tout nombre avec un «+» en tête

Une alternative qui évite ces deux problèmes mineurs est

 public static boolean isNumeric(Ssortingng str) { return str.matches("[+-]?\\d*(\\.\\d+)?"); } 

Vous pouvez utiliser NumberFormat#parse :

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

Si vous utilisez Java pour développer une application Android, vous pouvez utiliser la fonction TextUtils.isDigitsOnly .

Voici ma réponse au problème.

Une méthode «catch all commod» que vous pouvez utiliser pour parsingr n’importe quelle chaîne avec n’importe quel type d’parsingur: isParsable(Object parser, Ssortingng str) . L’parsingur peut être une Class ou un object . Cela vous permettra également d’utiliser des parsingurs personnalisés que vous avez écrits et qui devraient fonctionner dans tous les cas, par exemple:

 isParsable(Integer.class, "11"); isParsable(Double.class, "11.11"); Object dateFormater = new java.text.SimpleDateFormat("yyyy.MM.dd G 'at' HH:mm:ss z"); isParsable(dateFormater, "2001.07.04 AD at 12:08:56 PDT"); 

Voici mon code complet avec les descriptions de méthodes.

 import java.lang.reflect.*; /** * METHOD: isParsable

* * This method will look through the methods of the specified from parameter * looking for a public method name starting with "parse" which has only one Ssortingng * parameter.

* * The parser parameter can be a class or an instantiated object, eg: * Integer.class or new Integer(1). If you use a * Class type then only static methods are considered.

* * When looping through potential methods, it first looks at the Class associated * with the parser parameter, then looks through the methods of the parent's class * followed by subsequent ancestors, using the first method that matches the criteria specified * above.

* * This method will hide any normal parse exceptions, but throws any exceptions due to * programmatic errors, eg: NullPointerExceptions, etc. If you specify a parser * parameter which has no matching parse methods, a NoSuchMethodException will be thrown * embedded within a RuntimeException.

* * Example:
* isParsable(Boolean.class, "true");
* isParsable(Integer.class, "11");
* isParsable(Double.class, "11.11");
* Object dateFormater = new java.text.SimpleDateFormat("yyyy.MM.dd G 'at' HH:mm:ss z");
* isParsable(dateFormater, "2001.07.04 AD at 12:08:56 PDT");
*

* * @param parser The Class type or instantiated Object to find a parse method in. * @param str The Ssortingng you want to parse * * @return true if a parse method was found and completed without exception * @throws java.lang.NoSuchMethodException If no such method is accessible */ public static boolean isParsable(Object parser, Ssortingng str) { Class theClass = (parser instanceof Class? (Class)parser: parser.getClass()); boolean staticOnly = (parser == theClass), foundAtLeastOne = false; Method[] methods = theClass.getMethods(); // Loop over methods for (int index = 0; index < methods.length; index++) { Method method = methods[index]; // If method starts with parse, is public and has one String parameter. // If the parser parameter was a Class, then also ensure the method is static. if(method.getName().startsWith("parse") && (!staticOnly || Modifier.isStatic(method.getModifiers())) && Modifier.isPublic(method.getModifiers()) && method.getGenericParameterTypes().length == 1 && method.getGenericParameterTypes()[0] == String.class) { try { foundAtLeastOne = true; method.invoke(parser, str); return true; // Successfully parsed without exception } catch (Exception exception) { // If invoke problem, try a different method /*if(!(exception instanceof IllegalArgumentException) && !(exception instanceof IllegalAccessException) && !(exception instanceof InvocationTargetException)) continue; // Look for other parse methods*/ // Parse method refuses to parse, look for another different method continue; // Look for other parse methods } } } // No more accessible parse method could be found. if(foundAtLeastOne) return false; else throw new RuntimeException(new NoSuchMethodException()); } /** * METHOD: willParse

* * A convienence method which calls the isParseable method, but does not throw any exceptions * which could be thrown through programatic errors.

* * Use of {@link #isParseable(Object, Ssortingng) isParseable} is recommended for use so programatic * errors can be caught in development, unless the value of the parser parameter is * unpredictable, or normal programtic exceptions should be ignored.

* * See {@link #isParseable(Object, Ssortingng) isParseable} for full description of method * usability.

* * @param parser The Class type or instantiated Object to find a parse method in. * @param str The Ssortingng you want to parse * * @return true if a parse method was found and completed without exception * @see #isParseable(Object, Ssortingng) for full description of method usability */ public static boolean willParse(Object parser, Ssortingng str) { try { return isParsable(parser, str); } catch(Throwable exception) { return false; } }

Pour faire correspondre uniquement les entiers de base dix positifs, qui ne contiennent que des chiffres ASCII, utilisez:

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

Voici ma classe pour vérifier si une chaîne est numérique. Il corrige également les 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 les caractères non numériques [“12.00sdfsdf00” -> “12”]
  4. Traite les valeurs de chaîne négatives [“-12,020000” -> “-12.02”]
  5. Supprime plusieurs points [“-12.0.20.000” -> “-12.02”]
  6. Aucune bibliothèque supplémentaire, juste Java standard

Voici…

 public class NumUtils { /** * Transforms a ssortingng to an integer. If no numerical chars returns a Ssortingng "0". * * @param str * @return retStr */ static Ssortingng makeToInteger(Ssortingng str) { Ssortingng s = str; double d; d = Double.parseDouble(makeToDouble(s)); int i = (int) (d + 0.5D); Ssortingng retStr = Ssortingng.valueOf(i); System.out.printf(retStr + " "); return retStr; } /** * Transforms a ssortingng to an double. If no numerical chars returns a Ssortingng "0". * * @param str * @return retStr */ static Ssortingng makeToDouble(Ssortingng str) { Boolean dotWasFound = false; Ssortingng orgStr = str; Ssortingng 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 ssortingng 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; } } 

Les exceptions sont coûteuses, mais dans ce cas, le RegEx prend beaucoup plus de temps. Le code ci-dessous montre un test simple de deux fonctions – l’une utilisant des exceptions et l’autre utilisant des expressions rationnelles. Sur ma machine, la version RegEx est 10 fois plus lente que l’exception.

 import java.util.Date; public class IsNumeric { public static boolean isNumericOne(Ssortingng s) { return s.matches("-?\\d+(\\.\\d+)?"); //match a number with optional '-' and decimal. } public static boolean isNumericTwo(Ssortingng s) { try { Double.parseDouble(s); return true; } catch (Exception e) { return false; } } public static void main(Ssortingng [] args) { Ssortingng 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); } } 

Une approche performante qui évite les tentatives de prise et le traitement des nombres négatifs et de la notation scientifique.

 Pattern PATTERN = Pattern.comstack( "^(-?0|-?[1-9]\\d*)(\\.\\d+)?(E\\d+)?$" ); public static boolean isNumeric( Ssortingng value ) { return value != null && PATTERN.matcher( value ).matches(); } 

Regex Matching

Voici un autre exemple de mise à jour des expressions rationnelles “CraigTP” avec plus de validations.

 public static boolean isNumeric(Ssortingng str) { return str.matches("^(?:(?:\\-{1})?\\d+(?:\\.{1}\\d+)?)$"); } 
  1. Un seul signe négatif - autorisé et doit être au début.
  2. Après le signe négatif, il doit y avoir un chiffre.
  3. Un seul signe décimal . permis.
  4. Après le signe décimal, il doit y avoir un chiffre.

Test de regex

 1 -- **VALID** 1. -- INVALID 1.. -- INVALID 1.1 -- **VALID** 1.1.1 -- INVALID -1 -- **VALID** --1 -- INVALID -1. -- INVALID -1.1 -- **VALID** -1.1.1 -- INVALID 

// s’il vous plaît vérifier ci-dessous le code

 public static boolean isDigitsOnly(CharSequence str) { final int len = str.length(); for (int i = 0; i < len; i++) { if (!Character.isDigit(str.charAt(i))) { return false; } } return true; } 

C’est pourquoi j’aime l’approche Try * dans .NET. En plus de la méthode traditionnelle Parse, comme celle de Java, vous disposez également d’une méthode TryParse. Je ne suis pas bon en syntaxe Java (parameters sortants?), Alors veuillez traiter ce qui suit comme une sorte de pseudo-code. Cela devrait cependant clarifier le concept.

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

Usage:

 int num; if (parseInteger("23", out num)) { // Do something with num. } 
 // 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; } } 

Ceci est un exemple simple pour cette vérification:

 public static boolean isNumericSsortingng(Ssortingng input) { boolean result = false; if(input != null && input.length() > 0) { char[] charArray = input.toCharArray(); for(char c : charArray) { if(c >= '0' && c <= '9') { // it is a digit result = true; } else { result = false; break; } } } return result; } 

Parse it (ie with Integer#parseInt ) and simply catch the exception. =)

To clarify: The parseInt function checks if it can parse the number in any case (obviously) and if you want to parse it anyway, you are not going to take any performance hit by actually doing the parsing.

If you would not want to parse it (or parse it very, very rarely) you might wish to do it differently of course.

You can use the java.util.Scanner object.

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

Here are two methods that might work. (Without using Exceptions). Note : Java is a pass-by-value by default and a Ssortingng’s value is the address of the Ssortingng’s object data. So , when you are doing

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

You have changed the input value to have no spaces. You can remove that line if you want.

 private boolean isValidSsortingngNumber(Ssortingng ssortingngNumber) { if(ssortingngNumber.isEmpty()) { return false; } ssortingngNumber = ssortingngNumber.replaceAll(" ", ""); char [] charNumber = ssortingngNumber.toCharArray(); for(int i =0 ; i 

Here is another method in case you want to allow floats This method allegedly allows numbers in the form to pass 1,123,123,123,123,123.123 i have just made it , and i think it needs further testing to ensure it is working.

 private boolean isValidSsortingngTrueNumber(Ssortingng ssortingngNumber) { if(ssortingngNumber.isEmpty()) { return false; } ssortingngNumber = ssortingngNumber.replaceAll(" ", ""); int countOfDecimalPoint = 0; boolean decimalPointPassed = false; boolean commaFound = false; int countOfDigitsBeforeDecimalPoint = 0; int countOfDigitsAfterDecimalPoint =0 ; int commaCounter=0; int countOfDigitsBeforeFirstComma = 0; char [] charNumber = ssortingngNumber.toCharArray(); for(int i =0 ; i3)||(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; } 

I modified CraigTP’s solution to accept scientific notation and both dot and comma as decimal separators as well

 ^-?\d+([,\.]\d+)?([eE]-?\d+)?$ 

Exemple

 var re = new RegExp("^-?\d+([,\.]\d+)?([eE]-?\d+)?$"); re.test("-6546"); // true re.test("-6546355e-4456"); // true re.test("-6546.355e-4456"); // true, though debatable re.test("-6546.35.5e-4456"); // false re.test("-6546.35.5e-4456.6"); // false 

You can use NumberUtils.isCreatable() from Apache Commons Lang .

Since NumberUtils.isNumber will be deprecated in 4.0, so use NumberUtils.isCreatable() instead.

This is the fastest way i know to check if Ssortingng is Number or not:

 public static boolean isNumber(Ssortingng str){ int i=0, len=str.length(); boolean a=false,b=false,c=false, d=false; if(i 

Parallel checking for very long ssortingngs using IntStream

In Java 8, the following tests if all characters of the given ssortingng are within ‘0’ to ‘9’. Mind that the empty ssortingng is accepted:

 ssortingng.chars().unordered().parallel().allMatch( i -> '0' <= i && '9' >= i ) 

I think the only way to reliably tell if a ssortingng is a number, is to parse it. So I would just parse it, and if it’s a number, you get the number in an int for free!

You could use BigDecimal if the ssortingng may contain decimals:

 try { new java.math.BigInteger(testSsortingng); } catch(NumberFormatException e) { throw new RuntimeException("Not a valid number"); }