Как проверить, является ли String числовым в Java

Как бы вы проверили, была ли строка числом до ее parsingа?

    С Apache Commons Lang 3.5 и выше: NumberUtils.isCreatable или StringUtils.isNumeric .

    С Apache Commons Lang 3.4 и ниже: NumberUtils.isNumber или StringUtils.isNumeric .

    Вы также можете использовать StringUtils.isNumericSpace который возвращает true для пустых строк и игнорирует внутренние пробелы в строке. (Связанные javadocs содержат подробные примеры для каждого метода.)

    Обычно это делается с помощью простой пользовательской функции (т.е. функция Roll-your-own «isNumeric»).

    Что-то вроде:

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

    Однако, если вы вызываете эту функцию много, и вы ожидаете, что многие из проверок будут терпеть неудачу из-за того, что не будет числа, производительность этого механизма будет невелика, поскольку вы полагаетесь на исключения, которые бросаются на каждый сбой, что является довольно дорогостоящей операцией.

    Альтернативным подходом может быть использование регулярного выражения для проверки действительности числа:

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

    Однако будьте осторожны с вышеупомянутым механизмом RegEx, поскольку он будет терпеть неудачу, если вы используете неарабские цифры (например, цифры, отличные от 0 до 9). Это связано с тем, что часть «\ d» RegEx будет соответствовать только [0-9] и эффективно не воспринимается на международном уровне. (Спасибо OregonGhost за это!)

    Или еще одна альтернатива заключается в использовании встроенного Java-объекта java.text.NumberFormat Java, чтобы увидеть, если после parsingа строки позиция парсера находится в конце строки. Если это так, мы можем предположить, что вся строка является числовой:

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

    если вы находитесь на android, то вы должны использовать:

     android.text.TextUtils.isDigitsOnly(CharSequence str) 

    документацию можно найти здесь

    держите это просто . в основном каждый может «перепрограммировать» (то же самое).

    Как отметил @CraigTP в своем превосходном ответе, у меня также есть аналогичные проблемы с производительностью при использовании Exceptions, чтобы проверить, является ли строка числовой или нет. Поэтому я заканчиваю разделение строки и использую java.lang.Character.isDigit() .

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

    Согласно Javadoc , Character.isDigit(char) будет правильно распознавать нелатинские цифры. С точки зрения производительности, я думаю, что простое N число сравнений, где N – количество символов в строке, было бы более вычислительно эффективным, чем выполнение регулярного выражения.

    ОБНОВЛЕНИЕ: Как отметил Жан-Франсуа Корбетт в комментарии, вышеупомянутый код будет только проверять положительные целые числа, которые охватывают большинство моих вариантов использования. Ниже приведен обновленный код, который корректно проверяет десятичные числа в соответствии с языковой установкой по умолчанию, используемой в вашей системе, с предположением, что разделитель десятичных знаков встречается только один раз в строке.

     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; } 

    Ява-выражения Java 8.

     String someString = "123123"; boolean isNumeric = someString.chars().allMatch( Character::isDigit ); 

    Библиотека Ints.tryParse Google предоставляет хороший вспомогательный метод для этого: Ints.tryParse . Вы используете его как Integer.parseInt но он возвращает null а не бросает исключение, если строка не анализирует действительное целое число. Обратите внимание, что он возвращает Integer, а не int, поэтому вам нужно преобразовать / autobox его обратно в int.

    Пример:

     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 -1 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 

    Однако, с текущей версии – Guava r11 – он по-прежнему отмечен @Beta.

    Я не сравнивал это. Глядя на исходный код, есть некоторые накладные расходы из многих проверок здравомыслия, но в конце они используют Character.digit(string.charAt(idx)) , похожий, но немного отличный от ответа от @Ibrahim выше. Накладные расходы на обработку исключений не предусмотрены в рамках их реализации.

    Не используйте исключения для проверки ваших значений. Используйте Util libs вместо apache NumberUtils:

     NumberUtils.isNumber(myStringValue); 

    Изменить :

    Обратите внимание, что если ваша строка начинается с 0, NumberUtils будет интерпретировать ваше значение как шестнадцатеричное.

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

    Почему все стремятся к решениям для исключений / регулярных выражений?

    Хотя я могу понять, что большинство людей отлично справляются с использованием try / catch, если вы хотите часто это делать … это может быть чрезвычайно облагаемым налогом.

    То, что я сделал здесь, – это использовать регулярное выражение, методы parseNumber () и метод поиска массива, чтобы узнать, какой из них наиболее эффективен. На этот раз я только посмотрел на целые числа.

     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; } 

    Результаты в скорости я получил:

     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 

    Отказ от ответственности: я не утверждаю, что эти методы на 100% оптимизированы, они предназначены только для демонстрации данных

    Исключения выиграны, если и только если число равно 4 символам или меньше, и каждая строка всегда является числом ... в этом случае, почему даже есть чек?

    Короче говоря, очень сложно, если вы часто сталкиваетесь с недопустимыми числами с помощью try / catch, что имеет смысл. Важным правилом, которым я всегда придерживаюсь, НИКОГДА не используйте try / catch для streamа программы . Это пример, почему.

    Интересно, что простой, если char <0 || > 9 было очень просто писать, легко запоминается (и должно работать на нескольких языках) и выигрывает почти все тестовые сценарии.

    Единственным недостатком является то, что я предполагаю, что Integer.parseInt () может обрабатывать не ASCII-числа, тогда как метод поиска массива не работает.


    Для тех, кто задавался вопросом, почему я сказал, что легко запомнить характерный массив, если вы знаете, что нет никаких отрицательных признаков, вы можете легко уйти от чего-то сжатого:

     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; 

    Наконец, в качестве заключительной заметки, мне было любопытно, как оператор-ассистент в принятом примере со всеми голосами. Добавление в задание

     double d = Double.parseDouble(...) 

    это не только бесполезно, поскольку вы даже не используете значение, но оно тратит время обработки и увеличивает время выполнения на несколько наносекунд (что привело к увеличению тестов на 100-200 мс). Я не понимаю, почему кто-то это сделает, поскольку на самом деле это дополнительная работа по снижению производительности.

    Вы бы подумали, что это будет оптимизировано ... хотя, возможно, я должен проверить байт-код и посмотреть, что делает компилятор. Это не объясняет, почему это всегда показалось мне более длинным, хотя, если оно каким-то образом оптимизировано ... поэтому мне интересно, что происходит. В качестве примечания: по длине я имею в виду запуск теста для 10000000 итераций, и запуск этой программы несколько раз (10x +) всегда показывал, что она медленнее.

    EDIT: Обновлен тест для Character.isDigit ()

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

    Регулярное выражение CraigTP (показано выше) создает некоторые ложные срабатывания. Например, «23y4» будет считаться номером, потому что «.» соответствует любому символу, а не десятичной точке.

    Также он отклонит любое число с ведущим «+»

    Альтернативой, которая позволяет избежать этих двух второстепенных проблем, является

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

    Вы можете использовать NumberFormat#parse :

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

    Если вы используете java для разработки Android-приложения, вы можете использовать функцию TextUtils.isDigitsOnly .

    Вот мой ответ на эту проблему.

    Ухватите все удобные методы, которые вы можете использовать для синтаксического анализа любой строки с любым синтаксическим анализатором: isParsable(Object parser, String str) . Парсер может быть Class или object . Это также позволит вам использовать пользовательские парсеры, которые вы написали, и должен работать на любой сценарий, например:

     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"); 

    Вот мой код, полный описаний методов.

     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 String * 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 String 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, String 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, String) 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, String) isParseable} for full description of method * usability.

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

    Чтобы соответствовать только положительным целым числам base-ten, которые содержат только цифры ASCII, используйте:

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

    Вот мой class для проверки, является ли строка числовой. Он также фиксирует числовые строки:

    Особенности:

    1. Удаляет ненужные нули [“12.0000000” -> “12”]
    2. Удаляет ненужные нули [“12.0580000” -> “12.058”]
    3. Удаляет нецифровые символы [“12.00sdfsdf00” -> “12”]
    4. Обрабатывает отрицательные строковые значения [“-12,020000” -> “-12.02”]
    5. Удаляет несколько точек [“-12.0.20.000” -> “-12.02”]
    6. Никаких дополнительных библиотек, просто стандартных Java

    Ну вот…

     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; } } 

    Исключения стоят дорого, но в этом случае RegEx занимает гораздо больше времени. В приведенном ниже коде показан простой тест двух функций: один с использованием исключений и один с использованием регулярного выражения. На моей машине версия RegEx в 10 раз медленнее, чем исключение.

     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); } } 

    Хорошо выполненный подход, избегающий попыток захвата и обработки отрицательных чисел и научной нотации.

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

    Соответствие регулярных выражений

    Вот еще один пример обновленного соответствия регулярного выражения CraigTP с большим количеством проверок.

     public static boolean isNumeric(String str) { return str.matches("^(?:(?:\\-{1})?\\d+(?:\\.{1}\\d+)?)$"); } 
    1. Только один отрицательный знак - разрешен и должен начинаться.
    2. После отрицательного знака должна быть цифра.
    3. Только один десятичный знак . позволил.
    4. После десятичного знака должна быть цифра.

    Тест 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 

    // см. ниже код

     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; } 

    Вот почему мне нравится подход Try * в .NET. В дополнение к традиционному методу Parse, подобному Java, у вас также есть метод TryParse. Я не очень хорошо разбираюсь в синтаксисе Java (out parameters?), Поэтому, пожалуйста, рассматривайте следующее как своего рода псевдокод. Однако это должно сделать концепцию понятной.

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

    Применение:

     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; } } 

    Это простой пример для этой проверки:

     public static boolean isNumericString(String 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; } 

    Разберите его (т.е. с Integer#parseInt ) и просто поймайте исключение. знак равно

    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(String 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 String’s value is the address of the String’s object data. So , when you are doing

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

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

     private boolean isValidStringNumber(String stringNumber) { if(stringNumber.isEmpty()) { return false; } stringNumber = stringNumber.replaceAll(" ", ""); char [] charNumber = stringNumber.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 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 ; 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+)?$ 

    пример

     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 String is Number or not:

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

    Parallel checking for very long strings using IntStream

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

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

    I think the only way to reliably tell if a string 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 string may contain decimals:

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

    Windows 7 больше не обнаруживает запоминающие устройства USB

    JQuery $ .ajax не работает в IE при перекрестных вызовах домена

    psql: FATAL: Идентификационная идентификация не удалась для пользователя «postgres»

    Java String – Смотрите, содержит ли строка только числа, а не буквы

    При использовании методов getOne и findOne Spring Data JPA

    Ошибка Eclipse: R не может быть разрешено переменной

    Bluetooth внезапно перешел на Windows 8.1 – запуск службы, отсутствие иконки в трее, никаких настроек

    Существуют ли полные примеры, которые используют все методы делегата NSURLConnection?

    Уменьшить размер MP4

    Как определить, был ли взломан мой Linux-компьютер?

    Цикл на основе C ++ 11: получить элемент по значению или ссылке на const

    Является ли переход от Windows 8.1 Pro к Windows 7 Professional обратимым?

    Не удалось расширить раздел Windows

    C #: как – одно приложение экземпляра, которое принимает новые параметры?

    Как добавить существующее дерево каталогов в проект в Visual Studio?

    Давайте будем гением компьютера.