Как проверить строку на цифры java
Для того, чтобы проверить строку на цифры, можно воспользоваться методами класса StringUtils из библиотеки Apache Commons Lang . Этот класс содержит множество полезных методов, которые упрощают работу со строками. Для начала нужно установить в проект новую зависимость. Если вы используете gradle, нужно добавить в файл build.gradle в секцию dependencies такой код:
implementation 'org.apache.commons:commons-lang3:3.12.0' Затем класс нужно импортировать в том месте, где вы планируете его использовать:
import org.apache.commons.lang3.StringUtils; Для проверки строки на цифры, в классе есть статический метод isNumeric() . В качестве аргумента метод принимает последовательность символов CharSequence и возвращает булево значение в зависимости от того, состоит ли строка только из цифр.
StringUtils.isNumeric("hello"); // false StringUtils.isNumeric("hello12"); // false StringUtils.isNumeric("123"); // true Как проверить является ли строка числом java
Также можно воспользоваться методом StringUtils.isNumeric() :
import org.apache.commons.lang3.StringUtils; public class App public static void main(String[] args) System.out.println(StringUtils.isNumeric("123")); // => true System.out.println(StringUtils.isNumeric("12a3")); // => false > > 09 января 2023
Другой пример реализации метода с помощью регулярных выражений :
public static boolean isNumber(String str) return str.matches("-?\\d+"); > 09 января 2023
Приведенный ниже метод isNumber() проверит является ли строка числом :
public class App public static void main(String[] args) System.out.println(isNumber("123")); // => true System.out.println(isNumber("12q3")); // => false > public static boolean isNumber(String str) try Integer.parseInt(str); > catch (Exception e) return false; > return true; > > Как определить, является ли строка числом?
У меня тоже работает. Я просто про объявление throws NumberFormatException — по-моему оно лишнее, т.к. это исключение из функции никогда не вылетит.
2 дек 2011 в 22:39
Еще можно строку подвергнуть trim(), чтобы отсечь пробелы в начале и в конце (если это, конечно, не принципиально). По поводу имени функции — согласен с @Kremchik
2 дек 2011 в 23:03
Тут главный выбор из предложенных вариантов — выбор по скорости работы. Сделайте тестовую программку, прогоните эту функцию в разных вариантах много-много раз и проанализируйте время выполнения программы.
2 дек 2011 в 23:08
9 ответов 9
Сортировка: Сброс на вариант по умолчанию
Я так понимаю, цель именно на Integer проверить? Тогда можно:
s.matches("[-+]?\\d+") // для списка из 1 млн целых чисел и не чисел // (примерно 50/50) эффективность этой строчки практически // не отличается от описанной в вопросе функции. Если double , но без экспоненциальной нотации, то
((-|\\+)?[0-9]+(\\.[0-9]+)?)+ такое регулярное подойдёт.
Хотя я бы не парился и сделал бы точно так же, только с Double.parseDouble(s) , но я не показатель 🙂 И ещё я обратил внимание на название метода — оно не очень корректное, т.к. во-первых, такой есть в классе Character , во-вторых, по смыслу подходит isNumeric() . Но это просто комментарии из серии «что я думаю по этому поводу».
Отслеживать
ответ дан 2 дек 2011 в 22:58
2,828 14 14 серебряных знаков 18 18 бронзовых знаков
8 апр 2016 в 14:23
Проверка выражения является ли 2-1+1 числом, даёт положительный ответ.
24 сен 2019 в 6:06
Это же логично. Разве нет?
24 сен 2019 в 9:47
Спасибо, мне помогло!
14 мая 2021 в 11:12
Есть очень хороший static-метод в commons-lang (класс NumberUtils ), который учитывает множество особенностей чисел Java:
/** * Checks whether the String a valid Java number.
* * Valid numbers include hexadecimal marked with the 0x * qualifier, scientific notation and numbers marked with a type * qualifier (e.g. 123L).
* * Null and empty String will return * false.
* * @param str the String to check * @return true if the string is a correctly formatted number */ public static boolean isNumber(String str) Отслеживать
ответ дан 8 апр 2016 в 13:41
Evgeny Lazarev Evgeny Lazarev
1,120 1 1 золотой знак 8 8 серебряных знаков 14 14 бронзовых знаков
Метод, описанный в вопросе, и есть самый правильный метод.
Методы, которые проверяют, состоит ли строка лишь из цифр, не справятся с переполнением (попробуйте число 100000000000000000000000000000000 ). Правильный паттерн для целого числа такой:
^(-?([1-9][0-9] |1[0-9] |20[0-9] |21[0-3][0-9] |214[0-6][0-9] |2147[0-3][0-9] |21474[0-7][0-9] |214748[0-2][0-9] |2147483[0-5][0-9] |21474836[0-3][0-9] |214748364[0-7] ) |-2147483648 |0)$
и поверьте, вам не хочется отлаживать его или адаптировать для других типов.
При этом решения, основанные на паттернах, не будут учитывать локаль и разрешённые разделители разрядов. Так что попробовать распарсить и поймать исключение — практически единственно правильное решение.
Отслеживать
ответ дан 8 апр 2016 в 15:02
207k 28 28 золотых знаков 293 293 серебряных знака 526 526 бронзовых знаков
8 апр 2016 в 15:26
@Qwertiy: Ну, мало ли какие баги и где. Писать кривые велосипеды к багам отдельной версии отдельной платформы — неправильно.
8 апр 2016 в 15:27
Использовать исключения для стандартной логики — неправильно 🙂
8 апр 2016 в 15:33
@Qwertiy: Да, именно для этого и нужен этот метод — заврапить дыру в дизайне платформы. В .NET, например, есть честный int.TryParse .
8 апр 2016 в 15:34
@Qwertiy: Но создавать по сути два отдельных парсера int ‘а и молиться Гослингу, чтобы они оказались консистентными — очень неправильно. Логика разбора int из строки должна быть лишь в одном месте, и это место — Integer.parseInt .
8 апр 2016 в 15:36
В связи с повышенным интересом по данному вопросу, сделал маленькое исследование 🙂
В исследовании принимали участия классы:
CharacterDelegator() // код @Sergey ComplexMatcher() // код @VladD NumberUtilsDelegator() // мой код SimpleMatcher() // код @ivkremer (для простых чисел) GuavaDelegator() // код @Nofate♦ SimpleMatcherWithDot() // код @ivkremer (для чисел с точкой) SimpleParser() // оригинальный код от @pol GuavaComplexDelegator() // модифицированный вариант кода @Nofate♦ для Float InnerSetImpl() // мой специфический вариант (@VladD, извиняюсь, понимаю, что делает ваш регэксп, но завести его у меня не получилось)
Вывода много, поэтому вкратце:
- абсолютно все строки из примера распарсил только NumberUtils (commons-lang)
- вариант с использованием Guava (расширенный) справился со всем кроме long-нотаций («l») и «0xCAFEBABE» 🙂 (честно, не понимаю, почему он варианты с «f»-нотацией прожевал)
- остальные варианты в большей степени рассчитаны на парсинг именно интов, хотя в изначальном вопросе об этом ни слова 🙂
А вот самое интересное — это время работы данного кода.
Start performance test for core.impl.CharacterDelegator Ints: 125ms Numbers: 67ms Numbers with 25% errors: 50ms Small Ints: 43ms
Start performance test for core.impl.ComplexMatcher Ints: 10825ms Numbers: 11134ms Numbers with 25% errors: 10606ms Small Ints: 10380ms
Start performance test for core.impl.InnerSetImpl Ints: 50ms Numbers: 52ms Numbers with 25% errors: 54ms Small Ints: 42ms
Start performance test for core.impl.NumberUtilsDelegator Ints: 111ms Numbers: 91ms Numbers with 25% errors: 99ms Small Ints: 51ms
Start performance test for core.impl.SimpleMatcher Ints: 1072ms Numbers: 853ms Numbers with 25% errors: 847ms Small Ints: 766ms
Start performance test for core.impl.GuavaDelegator Ints: 131ms Numbers: 108ms Numbers with 25% errors: 124ms Small Ints: 119ms
Start performance test for core.impl.SimpleMatcherWithDot Ints: 3069ms Numbers: 5855ms Numbers with 25% errors: 5484ms Small Ints: 2548ms
Start performance test for core.impl.SimpleParser Ints: 157ms Numbers: 2189ms Numbers with 25% errors: 2117ms Small Ints: 81ms
Start performance test for core.impl.GuavaComplexDelegator Ints: 980ms Numbers: 943ms Numbers with 25% errors: 1016ms Small Ints: 837ms
Тест построен следующим образом
-
Генерируем 2 рандомных списка со стрингами (числа). Тут есть 4 варианта:
1. Просто Инты. 2. Числа (с 50% вероятностью в стринге есть точка). 3. Числа с возможной ошибкой (25% что в строке есть подстрока "error"). 4. Набор Интов в небольшом диапазоне.
Из приведенных выкладок видно, что NumberUtils работает быстрее всего. Схожее время работы у простого варианты Guava`ы и простых regexp. Даже добавление простой точки значительно замедляет код. Также замечу, что код @Sergey работает очень быстро, но он рассчитан на проверку строго интов.
А еще есть мой специфический пример InnerSetImpl . Он основан на допущении, что у нас есть ограниченное число возможных вариантов (то есть, мы можем и готовы держать их в памяти). Тогда мы просто помещаем их в HashSet и проверяем наличие строк в нем. Собственно, такой вариант самый быстрый, но допущение многое портит 🙂
ИТОГО: если нужно простое и элегантное решение — то лучше всего воспользоваться NumberUtils.isNumber(str) и не париться.
А если вдруг у вас стоит специфическая задача на парсинг не просто чисел, но чисел в Java-нотациях, то это единственный полностью рабочий вариант.
(Все вышесказанное относится только к приведенному коду. Я не исключаю, что можно придумать (или даже существует) более правильное или более быстрое решение).
Является ли строка числом
В данной статье мы узнаем, как осуществить проверку на то, является ли заданная строка числом. Мы рассмотрим несколько способов: с использованием внешних библиотек и с помощью стандартного API JavaSE.
Способ 1: проверка, является ли строка числом (Java API)
Здесь мы используем только стандартный API JavaSE. В первом варианте мы пытаемся привести строку к типу Double, и если у нас это получается, мы считаем, что указанная строка – число:
public static boolean isNumeric(String str) < try < Double.parseDouble(str); return true; >catch (NumberFormatException e) < return false; >>
С помощью этого метода вы можете проверить целые числа, дробные числа, числа с ведущим знаком плюса или минуса.
Способ 2: проверка, является ли строка числом (Apache Commons)
В этом способе мы используем библиотеку Apache Commons. Если у вас Maven проект, укажите следующий артефакт в вашем файле pom.xml:
org.apache.commons commons-lang3 3.9
С помощью метода NumberUtils.isParsable мы можем проверить, является ли указанная строка числом:
System.out.println(NumberUtils.isParsable("120.99")); // true System.out.println(NumberUtils.isParsable("+120.99f")); // true System.out.println(NumberUtils.isParsable("-120.99f")); // true System.out.println(NumberUtils.isParsable("120.99abc")); // false System.out.println(NumberUtils.isParsable("0xFF")); // false
Метод isParsable является обёрткой поверх Integer.parseInt, Long.parseLong, Float.parseFloat и Double.parseDouble. Его удобно использовать для того, чтобы самому не писать шаблонный код по перехвату исключений этих методов.
public class IsStringNumber1 < public static void main(String[] args) < System.out.println(isNumeric("120.99")); // true System.out.println(isNumeric("+120.99f")); // true System.out.println(isNumeric("-120.99")); // true System.out.println(isNumeric("120.99abc")); // false System.out.println(isNumeric("0xFF")); // false >public static boolean isNumeric(String str) < try < Double.parseDouble(str); return true; >catch (NumberFormatException e) < return false; >> >
import org.apache.commons.lang3.math.NumberUtils; public class IsStringNumber2 < public static void main(String[] args) < System.out.println(NumberUtils.isParsable("120.99")); // true System.out.println(NumberUtils.isParsable("+120.99f")); // true System.out.println(NumberUtils.isParsable("-120.99f")); // true System.out.println(NumberUtils.isParsable("120.99abc")); // false System.out.println(NumberUtils.isParsable("0xFF")); // false >>
Заключение
Мы рассмотрели различные способы проверить строку на то, является ли она числом.
Является ли строка числом
- ← Проверка версии Java
- Вывод в консоль →