Java проверить строка содержит только цифры

Rukovodstvo

статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.

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

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

Вступление

Строки — это удобный способ передачи информации и получения ввода от пользователя.

В этой статье мы рассмотрим несколько способов проверить, является ли String числовым в Java, то есть представляет ли String числовое значение.

Проверьте, является ли строка числовой с помощью Core Java

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

Самый простой способ проверить, является ли String числовым или нет, — использовать один из следующих встроенных методов Java:

1. Integer.parseInt()
2. Integer.valueOf()
3. Double.parseDouble()
4. Float.parseFloat()
5. Long.parseLong()

Эти методы преобразуют заданную String в ее числовой эквивалент. Если они не могут его преобразовать, NumberFormatException , указывающее, что строка не является числовой.

Стоит отметить, что Integer.valueOf() возвращает new Integer() , а Integer.parseInt() возвращает примитивный int . Имейте это в виду, если такая разница изменит ход вашей программы.

 String string = "10"; try < intValue = Integer.parseInt(string); return true; >catch (NumberFormatException e)

Теперь для удобства мы можем абстрагировать эту функциональность во вспомогательный метод:

 public static boolean isNumeric(String string) < int intValue; System.out.println(String.format("Parsing string: \"%s\"", string)); if(string == null || string.equals("")) < System.out.println("String cannot be parsed, it is null or empty."); return false; >try < intValue = Integer.parseInt(string); return true; >catch (NumberFormatException e) < System.out.println("Input String cannot be parsed to Integer."); >return false; > 

Теперь мы можем просто позвонить:

 String string = "10"; if(isNumeric(string)) < System.out.println("String is numeric!"); // Do something >else

Выполнение этого кода приведет к:

 Parsing string: "10" String is numeric! 

С другой стороны, если мы ожидаем, что String будет содержать действительно большое число, мы можем вызвать конструктор BigInteger(String) , который переводит представление String BigInteger .

Проверьте, является ли строка числовой с помощью Apache Commons

Apache Commons — одна из наиболее часто используемых сторонних библиотек для расширения базовой Java Framework. Это дает нам более точный контроль над основными классами Java, в данном случае над строками.

Мы рассмотрим два класса из библиотеки Apache Commons:

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

Давайте теперь посмотрим, как мы можем проверить числовые значения с помощью этих методов.

NumberUtils.isParsable ()

Этот метод принимает String и проверяет, является ли это число, которое можно анализировать, или нет, мы можем использовать этот метод вместо перехвата исключения при вызове одного из методов, которые мы упоминали ранее.

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

Обратите внимание, что шестнадцатеричные числа и научные обозначения не считаются анализируемыми.

Теперь нам даже не нужен вспомогательный вспомогательный метод, поскольку isParseable() возвращает само boolean

 String string = "10"; if (NumberUtils.isParsable(string)) < System.out.println("String is numeric!"); >else

NumberUtils.isCreatable ()

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

Теперь мы даже можем использовать что-то вроде:

 String string = "0x10AB"; if (NumberUtils.isCreatable(string)) < System.out.println("String contains a creatable number!"); >else

 String contains a creatable number! 

NumberUtils.isDigits ()

Метод NumberUtils.isDigits() проверяет, содержит ли строка только цифры Unicode. Если String содержит начальный знак или десятичную точку, метод вернет false :

 String string = "25"; if (NumberUtils.isDigits(string)) < System.out.println("String is numeric!"); >else

StringUtils.isNumeric ()

StringUtils.isNumeric() является StringUtils эквивалент NumberUtils.isDigits() .

Если String проходит числовой тест, он все равно может генерировать NumberFormatException при синтаксическом анализе упомянутыми ранее методами, например, если он выходит за пределы диапазона для int или long .

Используя этот метод, мы можем определить, можем ли мы преобразовать String Integer :

 String string = "25"; if (StringUtils.isNumeric(string)) < System.out.println("String is numeric!"); >else

StringUtils.isNumericSpace ()

Кроме того, если мы ожидаем найти больше чисел в isNumericSpace , еще один полезный StringUtils стоит упомянуть. Он проверяет, String только цифры или пробелы Unicode.

Давайте проверим строку, содержащую числа и пробелы:

 String string = "25 50 15"; if (StringUtils.isNumericSpace(string)) < System.out.println("String is numeric!"); >else

Проверьте, является ли строка числовой с помощью Regex

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

 public static boolean isNumeric(String string) < // Checks if the provided string // is a numeric by applying a regular // expression on it. String regex = "3+[\\.]?4*"; return Pattern.matches(regex, string); >

А затем мы можем вызвать этот метод:

 System.out.println("123: " + isStringNumeric2("123")); System.out.println("I'm totally a numeric, trust me: " + isStringNumeric2("I'm totally a numeric, trust me")); 

Выполнение этого дает нам следующий результат:

 123: true I'm totally a numeric, trust me: false 

Заключение

В этой статье мы рассмотрели несколько способов проверить, является ли строка числовой или нет (представляет собой число) в Java.

Мы начали с Core Java и NumberFormatException , после чего использовали библиотеку Apache Commons. Оттуда мы использовали StringUtils и NumberUtils чтобы проверить, является ли String числовым или нет, с различными форматами.

Licensed under CC BY-NC-SA 4.0

Источник

Как определить, является ли строка числом?

У меня тоже работает. Я просто про объявление throws NumberFormatException — по-моему оно лишнее, т.к. это исключение из функции никогда не вылетит.

Еще можно строку подвергнуть trim(), чтобы отсечь пробелы в начале и в конце (если это, конечно, не принципиально). По поводу имени функции — согласен с @Kremchik

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

9 ответов 9

Я так понимаю, цель именно на Integer проверить? Тогда можно:

s.matches("[-+]?\\d+") // для списка из 1 млн целых чисел и не чисел // (примерно 50/50) эффективность этой строчки практически // не отличается от описанной в вопросе функции. 

Если double , но без экспоненциальной нотации, то

такое регулярное подойдёт.

Хотя я бы не парился и сделал бы точно так же, только с Double.parseDouble(s) , но я не показатель 🙂 И ещё я обратил внимание на название метода — оно не очень корректное, т.к. во-первых, такой есть в классе Character , во-вторых, по смыслу подходит isNumeric() . Но это просто комментарии из серии «что я думаю по этому поводу».

Есть очень хороший 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) 

Метод, описанный в вопросе, и есть самый правильный метод.

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

 ^(-?(95 |16 |207 |2123 |21441 |214734 |2147441 |21474819 |214748358 |2147483614 |2147483647 ) |-2147483648 |0)$ 

и поверьте, вам не хочется отлаживать его или адаптировать для других типов.

При этом решения, основанные на паттернах, не будут учитывать локаль и разрешённые разделители разрядов. Так что попробовать распарсить и поймать исключение — практически единственно правильное решение.

@Qwertiy: Ну, мало ли какие баги и где. Писать кривые велосипеды к багам отдельной версии отдельной платформы — неправильно.

@Qwertiy: Да, именно для этого и нужен этот метод — заврапить дыру в дизайне платформы. В .NET, например, есть честный int.TryParse .

@Qwertiy: Но создавать по сути два отдельных парсера int ‘а и молиться Гослингу, чтобы они оказались консистентными — очень неправильно. Логика разбора int из строки должна быть лишь в одном месте, и это место — Integer.parseInt .

В связи с повышенным интересом по данному вопросу, сделал маленькое исследование 🙂

В исследовании принимали участия классы:

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-нотациях, то это единственный полностью рабочий вариант.

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

Источник