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

С Apache Commons Lang 3.5 и выше: _ 1_ или StringUtils.isNumeric.

С Apache Commons Lang 3.4 и ниже: _ 3_ или StringUtils.isNumeric.

Вы также можете использовать _ 5_, который возвращает true для пустых строк и игнорирует внутренние пробелы в строке. Другой способ - использовать _ 7_, который в основном проверяет, является ли число доступным для синтаксического анализа в соответствии с Java. (Связанные документы javadoc содержат подробные примеры для каждого метода.)

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

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

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

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

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

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

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

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

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

если у вас Android, то вам следует использовать:

android.text.TextUtils.isDigitsOnly(CharSequence str)

можно найти здесь

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

Лямбда-выражения Java 8.

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

Как упомянул @CraigTP в своем превосходном ответе, у меня также есть аналогичные проблемы с производительностью при использовании исключений для проверки того, является ли строка числовой или нет. В итоге я разбиваю строку и использую 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;
}

Библиотека Google Guava предоставляет для этого хороший вспомогательный метод: 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

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

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

Не используйте исключения для проверки своих значений. Вместо этого используйте библиотеки Util, например 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 для выполнения программы. Это пример того, почему.

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

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

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

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 +) всегда показывал, что он был медленнее.

РЕДАКТИРОВАТЬ: обновлен тест для 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+)?");
}

Мы можем попробовать заменить все числа в данной строке на (), т.е. пробел, и если после этого длина строки будет равна нулю, то мы можем сказать, что данная строка содержит только числа. Пример:

boolean isNumber(String str){
        if(str.length() == 0)
            return false; //To check if string is empty
        
        if(str.charAt(0) == '-')
            str = str.replaceFirst("-","");// for handling -ve numbers
    
        System.out.println(str);
        
        str = str.replaceFirst("\\.",""); //to check if it contains more than one decimal points
        
        if(str.length() == 0)
            return false; // to check if it is empty string after removing -ve sign and decimal point
        System.out.println(str);
        
        return str.replaceAll("[0-9]","").length() == 0;
    }

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

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

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

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

Удобный метод catch all, который можно использовать для синтаксического анализа любой строки с любым типом синтаксического анализатора: 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<p><p>
 * 
 * This method will look through the methods of the specified <code>from</code> parameter
 * looking for a public method name starting with "parse" which has only one String
 * parameter.<p>
 * 
 * The <code>parser</code> parameter can be a class or an instantiated object, eg:
 * <code>Integer.class</code> or <code>new Integer(1)</code>. If you use a
 * <code>Class</code> type then only static methods are considered.<p>
 * 
 * When looping through potential methods, it first looks at the <code>Class</code> associated
 * with the <code>parser</code> 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.<p>
 * 
 * This method will hide any normal parse exceptions, but throws any exceptions due to
 * programmatic errors, eg: NullPointerExceptions, etc. If you specify a <code>parser</code>
 * parameter which has no matching parse methods, a NoSuchMethodException will be thrown
 * embedded within a RuntimeException.<p><p>
 * 
 * Example:<br>
 * <code>isParsable(Boolean.class, "true");<br>
 * isParsable(Integer.class, "11");<br>
 * isParsable(Double.class, "11.11");<br>
 * Object dateFormater = new java.text.SimpleDateFormat("yyyy.MM.dd G 'at' HH:mm:ss z");<br>
 * isParsable(dateFormater, "2001.07.04 AD at 12:08:56 PDT");<br></code>
 * <p>
 * 
 * @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<p><p>
 * 
 * A convienence method which calls the isParseable method, but does not throw any exceptions
 * which could be thrown through programatic errors.<p>
 * 
 * Use of {@link #isParseable(Object, String) isParseable} is recommended for use so programatic
 * errors can be caught in development, unless the value of the <code>parser</code> parameter is
 * unpredictable, or normal programtic exceptions should be ignored.<p>
 * 
 * See {@link #isParseable(Object, String) isParseable} for full description of method
 * usability.<p>
 * 
 * @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;
    }
}

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

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. После десятичного знака должна быть цифра.

Тест регулярного выражения

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

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

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

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

Функции:

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

}

}

// пожалуйста, проверьте код ниже

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

Вы можете использовать объект java.util.Scanner.

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

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

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

Я проиллюстрировал некоторые условия для проверки чисел и десятичных знаков без использования какого-либо API,

Проверить длину исправления 1-значное число

Character.isDigit(char)

Проверьте число фиксированной длины (предположим, что длина равна 6)

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

Проверьте число переменной длины между (предположим, что длина от 4 до 6)

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

Проверьте десятичное число переменной длины между (предположим, что длина от 4 до 7)

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

Надеюсь, это поможет многим.

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

Он проверяет максимум один знак минус и проверяет максимум одну десятичную точку.

Вот несколько примеров и их результаты:

«1», «-1», «-1,5» и «-1,556» возвращают значение true.

«1..5», «1A.5», «1.5D», «-» и «--1» возвращают false

Примечание. При необходимости вы можете изменить это, чтобы принять параметр языкового стандарта и передать его в вызовы DecimalFormatSymbols.getInstance (), чтобы использовать конкретный языковой стандарт вместо текущего.

 public static boolean isNumeric(final String input) {
    //Check for null or blank string
    if(input == null || input.isBlank()) return false;

    //Retrieve the minus sign and decimal separator characters from the current Locale
    final var localeMinusSign = DecimalFormatSymbols.getInstance().getMinusSign();
    final var localeDecimalSeparator = DecimalFormatSymbols.getInstance().getDecimalSeparator();

    //Check if first character is a minus sign
    final var isNegative = input.charAt(0) == localeMinusSign;
    //Check if string is not just a minus sign
    if (isNegative && input.length() == 1) return false;

    var isDecimalSeparatorFound = false;

    //If the string has a minus sign ignore the first character
    final var startCharIndex = isNegative ? 1 : 0;

    //Check if each character is a number or a decimal separator
    //and make sure string only has a maximum of one decimal separator
    for (var i = startCharIndex; i < input.length(); i++) {
        if(!Character.isDigit(input.charAt(i))) {
            if(input.charAt(i) == localeDecimalSeparator && !isDecimalSeparatorFound) {
                isDecimalSeparatorFound = true;
            } else return false;
        }
    }
    return true;
}

Я изменил решение CraigTP, чтобы принять научную нотацию, а также точку и запятую в качестве десятичных разделителей.

^-?\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

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

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

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

Чтобы уточнить: функция parseInt проверяет, может ли она анализировать число в любом случае (очевидно), и если вы все равно хотите его проанализировать, вы не собираетесь снижать производительность, фактически выполняя синтаксический анализ.

Если вы не хотите анализировать его (или анализировать очень и очень редко), вы, конечно, можете сделать это по-другому.

Вы можете использовать NumberUtils.isCreatable () из Apache Commons Lang .

Поскольку NumberUtils.isNumber будет устаревшим в версии 4.0, используйте вместо него NumberUtils.isCreatable ().

Java 8 Stream, лямбда-выражение, функциональный интерфейс

Все дела обработаны (строка пуста, строка пуста и т. Д.)

String someString = null; // something="", something="123abc", something="123123"

boolean isNumeric = Stream.of(someString)
            .filter(s -> s != null && !s.isEmpty())
            .filter(Pattern.compile("\\D").asPredicate().negate())
            .mapToLong(Long::valueOf)
            .boxed()
            .findAny()
            .isPresent();

Я думаю, что единственный способ надежно определить, является ли строка числом, - это проанализировать ее. Поэтому я бы просто проанализировал его, и если это число, вы получите число в int бесплатно!

Вот два метода, которые могут сработать. (Без использования исключений). Примечание. Java по умолчанию передается по значению, а значение String - это адрес данных объекта String. Итак, когда вы делаете

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

Вы изменили входное значение, чтобы в нем не было пробелов. Вы можете удалить эту строку, если хотите.

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

Вот еще один метод на случай, если вы хотите разрешить поплавки. Этот метод якобы позволяет числам в форме передавать 1,123,123,123,123,123,123. Я только что сделал это, и я думаю, что требуется дальнейшее тестирование, чтобы убедиться, что он работает.

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

Вы можете использовать BigDecimal, если строка может содержать десятичные знаки:

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

Если вы хотите выполнить проверку с использованием регулярного выражения, вы должны создать окончательный статический объект Pattern, таким образом, регулярное выражение необходимо скомпилировать только один раз. Компиляция регулярного выражения занимает примерно столько же времени, сколько и выполнение сопоставления, поэтому, приняв эту меру предосторожности, вы сократите время выполнения метода вдвое.

final static Pattern NUMBER_PATTERN = Pattern.compile("[+-]?\\d*\\.?\\d+");

static boolean isNumber(String input) {
    Matcher m = NUMBER_PATTERN.matcher(input);
    return m.matches();
}

Я предполагаю, что число представляет собой строку, в которой нет ничего, кроме десятичных цифр, возможно, знак + или - в начале и не более одной десятичной точки (не в конце) и никаких других символов (включая запятые, пробелы, числа в другие системы счета, римские цифры, иероглифы).

Это краткое и довольно быстрое решение, но вы можете сэкономить пару миллисекунд на миллион вызовов, сделав это следующим образом

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

Попробуй это:

public  boolean isNumber(String str)
{       
    short count = 0;
    char chc[]  = {'0','1','2','3','4','5','6','7','8','9','.','-','+'};
    for (char c : str.toCharArray())
    {   
        for (int i = 0;i < chc.length;i++)
        {
            if( c  == chc[i]){
                count++;        
            }
         }                      
    }
    if (count != str.length() ) 
        return false;
    else
        return true;
}

Параллельная проверка очень длинных строк с помощью IntStream

В Java 8 следующие тесты проверяют, находятся ли все символы данного string в пределах от «0» до «9». Помните, что пустая строка принимается:

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

Это самый быстрый способ проверить, является ли строка числом или нет:

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<='9';
}

Если вы, ребята, используете следующий метод для проверки:

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

Тогда что случилось с вводом очень длинной строки, такой как я называю этот метод:

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

Результат "верный", также это слишком большое число! То же самое произойдет, если вы используете регулярное выражение для проверки! Поэтому я бы предпочел использовать метод "синтаксического анализа" для проверки, например:

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

И результат - то, что я ожидал!