Как проверить что строка это число java
Java: Проверьте, является ли строка числом
В этом уроке мы рассмотрим примеры того, как проверить, представляет ли строка число в Java. Мы будем использовать основную Java и библиотеку Apache Commons, а также регулярные выражения.
Вступление
Строки-это удобный способ передачи информации и получения входных данных от пользователя.
В этой статье мы рассмотрим несколько способов проверить, является ли строка числовой в Java – то есть, представляет ли строка числовое значение.
Проверьте, является ли строка числовой с помощью ядра Java
Пользователи, как правило, довольно часто вводят неверные входные значения, поэтому разработчикам приходится как можно больше держать их за руку во время операций ввода-вывода.
Самый простой способ проверить, является ли строка числовой или нет,-это использовать один из следующих встроенных методов Java:
Давайте попробуем это:
Теперь мы можем абстрагировать эту функциональность в вспомогательный метод для удобства:
Теперь мы можем просто позвонить:
Выполнение этого кода приведет к:
Проверьте, является ли строка числовой с помощью Apache Commons
Apache Commons является одной из наиболее часто используемых сторонних библиотек для расширения базовой платформы Java. Это дает нам более точный контроль над основными классами Java, в данном случае строками.
Мы рассмотрим два класса из библиотеки Apache Commons:
Оба из которых очень похожи на их аналоги ванильного класса Java, но с акцентом на безопасные для нуля операции (для чисел и строк соответственно), что означает, что мы даже можем определить значения по умолчанию для отсутствующих ( нулевых ) значений.
Давайте теперь посмотрим, как мы можем проверить числовые значения с помощью этих методов.
числа.Сопоставимо()
Этот метод принимает строку и проверяет, является ли это анализируемым числом или нет, мы можем использовать этот метод вместо того, чтобы перехватывать исключение при вызове одного из методов, о которых мы упоминали ранее.
Это очень хорошо, потому что решений, связанных с частой обработкой исключений, следует по возможности избегать – именно в этом нам помогает этот метод.
Обратите внимание, что шестнадцатеричные числа и научные обозначения не считаются поддающимися анализу.
Теперь нам даже не нужен вспомогательный метод для удобства, так как поддается анализу() возвращает логическое значение само по себе:
Git Essentials
Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!
Этот код должен возвращать:
NumberUtils.isCreatable()
Теперь мы можем даже использовать что-то вроде:
числа.isDigits()
StringUtils.IsNumeric()
Используя этот метод, мы можем определить, можем ли мы проанализировать Строку в Целое число :
StringUtils.isNumericSpace()
Давайте проверим строку, содержащую числа и пробелы:
Проверьте, является ли строка числовой с помощью регулярного выражения
Несмотря на то, что большинство разработчиков будут довольны использованием уже реализованного метода, иногда у вас может быть очень специфическая проверка шаблонов:
И тогда мы можем вызвать этот метод:
Выполнение этого дает нам следующий результат:
Вывод
В этой статье мы рассмотрели несколько способов проверить, является ли строка числовой или нет (представляет собой число) в Java.
Как определить, является ли строка числом?
Я делал так, но мне кажется такой подход в чем-то неправильным:
9 ответов 9
Я так понимаю, цель именно на Integer проверить? Тогда можно:
такое регулярное подойдёт.
Есть очень хороший static-метод в commons-lang (класс NumberUtils ), который учитывает множество особенностей чисел Java:
Метод, описанный в вопросе, и есть самый правильный метод.
Методы, которые проверяют, состоит ли строка лишь из цифр, не справятся с переполнением (попробуйте число 100000000000000000000000000000000 ). Правильный паттерн для целого числа такой:
и поверьте, вам не хочется отлаживать его или адаптировать для других типов.
При этом решения, основанные на паттернах, не будут учитывать локаль и разрешённые разделители разрядов. Так что попробовать распарсить и поймать исключение — практически единственно правильное решение.
В связи с повышенным интересом по данному вопросу, сделал маленькое исследование 🙂
В исследовании принимали участия классы:
(@VladD, извиняюсь, понимаю, что делает ваш регэксп, но завести его у меня не получилось)
Вывода много, поэтому вкратце:
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 варианта:
Делаем тестовый прогон на 10_000 элементах.
Из приведенных выкладок видно, что NumberUtils работает быстрее всего. Схожее время работы у простого варианты Guava`ы и простых regexp. Даже добавление простой точки значительно замедляет код. Также замечу, что код @Sergey работает очень быстро, но он рассчитан на проверку строго интов.
А если вдруг у вас стоит специфическая задача на парсинг не просто чисел, но чисел в Java-нотациях, то это единственный полностью рабочий вариант.
(Все вышесказанное относится только к приведенному коду. Я не исключаю, что можно придумать (или даже существует) более правильное или более быстрое решение).
Как проверить, является ли строка числовой в Java
Как бы вы проверили, была ли строка числом перед ее разбором?
30 ответов
вы также можете использовать StringUtils.isNumericSpace возвращает true для пустых строк и игнорирует внутренние пробелы в строке. (Связанной документации содержит подробные примеры для каждого метода.)
это обычно делается с помощью простой определяемой пользователем функции (т. е. свернуть свою собственную «числовую» функцию).
однако, если вы вызываете эту функцию много, и вы ожидаете, что многие из проверок потерпят неудачу из-за того, что не являются числом, производительность этого механизма не будет большой, так как вы полагаетесь на исключения, создаваемые для каждого сбоя, что является довольно дорогостоящей операцией.
альтернативным подходом может быть чтобы использовать регулярное выражение для проверки правильности числа:
будьте осторожны с вышеупомянутым механизмом регулярного выражения, хотя, поскольку он потерпит неудачу, если вы используете неарабские цифры (т. е. цифры, отличные от 0 до 9). Это связано с тем, что часть» \d » регулярного выражения будет соответствовать только 8 и фактически не является международной числовой информацией. (Спасибо OregonGhost за указание на это!)
или даже другой альтернативой является использование встроенного Java Ява.текст.Numberformat объект, чтобы увидеть, если после синтаксического анализа строки позиция синтаксического анализатора находится в конце строки. Если это так, мы можем предположить, что вся строка является числовым:
Если вы находитесь на Android, то вы должны использовать:
сохранить его простым. в основном каждый может «перепрограммировать» (то же самое).
UPDATE: как указал Жан-Франсуа Корбетт в комментарии, приведенный выше код будет проверять только положительные целые числа, которые охватывают большую часть моего варианта использования. Ниже приведен обновленный код, который правильно проверяет десятичные числа в соответствии с локалем по умолчанию, используемым в вашей системе, с предположением, что десятичный разделитель встречается только один раз в строке.
Java 8 лямбда-выражения.
не используйте исключения для проверки значений. Используйте util libs вместо apache NumberUtils:
редактировать:
обратите внимание, что если ваша строка начинается с 0, NumberUtils будет интерпретировать ваше значение как шестнадцатеричное.
почему все настаивают на решениях исключений / регулярных выражений?
хотя я могу понять, что большинство людей в порядке с использованием try / catch, если вы хотите делать это часто. это может быть чрезвычайно утомительно.
то, что я сделал здесь, это взять регулярное выражение, методы parseNumber() и метод поиска массива, чтобы увидеть, который был наиболее эффективным. На этот раз я смотрел только на целые числа.
результаты в скорости я получил были:
отказ от ответственности: я не утверждаю, что эти методы 100% оптимизированы, они просто для демонстрации данных
исключения выиграли, если и только если число 4 символа или меньше, и каждая строка всегда ряд. в таком случае зачем вообще чек?
короче говоря, это очень больно, если вы часто сталкиваетесь с недопустимыми числами с помощью try/catch, что имеет смысл. Важное правило я всегда следовать никогда не используйте try / catch для потока программы. Вот пример почему.
интересно, что простой, если char 9 был чрезвычайно прост в написании, легко запоминается (и должен работать на нескольких языках) и выигрывает почти все тестовые сценарии.
единственным недостатком является то, что я предполагаю целое число.parseInt () может обрабатывать номера, отличные от ASCII, в то время как метод поиска массива-нет.
для тех, кто интересуется, почему я сказал, что это легко помните, что массив символов один, если вы знаете, что нет отрицательных знаков, вы можете легко уйти с чем-то конденсированным, как это:
наконец, в качестве заключительного замечания мне было интересно узнать об операторе назначения в принятом примере со всеми голосами. Добавление в задание
не только бесполезно, так как вы даже не используете значение, но он тратит время обработки и увеличивает время выполнения на несколько наносекунд (что привело к 100-200 МС увеличение в тестах). Я не понимаю, зачем кому-то это делать, так как на самом деле это дополнительная работа для снижения производительности.
вы думаете, что это будет оптимизировано. хотя, возможно, я должен проверить байт-код и посмотреть, что делает компилятор. Это не объясняет, почему он всегда показывался мне более длинным, хотя если он каким-то образом оптимизирован. поэтому мне интересно, что происходит. Как Примечание: под lengthier я имею в виду запуск теста для 10000000 итераций и запуск этой программы несколько раз (10x+) всегда показывали, что он медленнее.
EDIT: обновлен тест для символа.isDigit()
также он будет отклонять любое число с ведущим’+’
альтернативой, которая позволяет избежать этих двух незначительных проблем, является
Какой лучший способ проверить, представляет ли String целое число в Java?
Обычно я использую следующую идиому, чтобы проверить, можно ли преобразовать строку в целое число.
Это только я, или это кажется немного хакерским? Какой способ лучше?
Сделал быстрый тест. Исключения на самом деле не такие уж и дорогие, если только вы не начнете использовать несколько методов, а JVM придется проделать большую работу, чтобы установить стек выполнения. Оставаясь в том же методе, они не плохие исполнители.
ByRegex: 453 (примечание: каждый раз перекомпилировать шаблон)
Я согласен, что решение Jonas K является самым надежным. Похоже, он выигрывает 🙂
Скопировано из Билла Ящера и дополнено скомпилированной версией:
хотя стандартная библиотека Java действительно пропускает такие вспомогательные функции
Я думаю, что Apache Commons является обязательным условием для каждого Java-программиста
Жаль, что он еще не портирован на Java5
Отчасти это зависит от того, что вы подразумеваете под «можно преобразовать в целое число».
Посимвольные проверки будут эффективно отклонять «не целое число» случаев, оставляя «это целое число, но Java не может его обработать», чтобы случаи были обнаружены более медленным маршрутом исключения. Вы можете сделать это немного вручную, но это будет намного сложнее.
Только один комментарий о регулярном выражении. Каждый приведенный здесь пример неверен! Если вы хотите использовать регулярные выражения, не забывайте, что компиляция шаблона занимает много времени. Это:
вызывает компиляцию шаблона в каждом вызове метода. Чтобы правильно его использовать следуйте:
Он вернет ноль вместо генерации исключения, если ему не удастся проанализировать строку.
Это короче, но короче не обязательно лучше (и оно не будет отлавливать целочисленные значения, выходящие за пределы диапазона, как указано в комментарии danatel ):
Лично, поскольку реализация спекулируется в вспомогательном методе, а правильность бьет по длине, я бы просто пошел с чем-то вроде того, что у вас есть (минус перехват базового Exception класса, а не NumberFormatException ).
Вы можете использовать метод совпадений строкового класса. 3 представляет все возможные значения, + означает, что длина должна быть не менее одного символа, а * означает, что длина может быть равна нулю или более.
Как проверить, является ли строка числовой в Java
Как бы вы проверили, является ли строка числом, прежде чем анализировать ее?
30 ответов
Обычно это делается с помощью простой определяемой пользователем функции (например, функции Roll-your-own «isNumeric»).
Однако, если вы часто вызываете эту функцию и ожидаете, что многие проверки завершатся ошибкой из-за того, что это не число, производительность этого механизма будет невысокой, так как вы полагаетесь на исключения, создаваемые для каждого сбоя, что является довольно дорогой операцией.
Альтернативный подход может заключаться в использовании регулярного выражения для проверки действительности числа:
Однако будьте осторожны с указанным выше механизмом RegEx, так как он не сработает, если вы используете неарабские цифры (то есть цифры, отличные от 0 до 9). Это связано с тем, что часть «\ d» регулярного выражения будет соответствовать только 1 и фактически не имеет международной числовой информации. (Спасибо OregonGhost за указание на это!)
Или даже другой альтернативой является использование встроенного в Java объекта java.text.NumberFormat, чтобы увидеть, находится ли после анализа строки позиция анализатора в конце строки. Если это так, мы можем предположить, что вся строка является числовой:
Если у вас Android, то вам следует использовать:
будь простым . в основном каждый может «перепрограммировать» (то же самое).
Лямбда-выражения Java 8.
ОБНОВЛЕНИЕ: как указал Жан-Франсуа Корбетт в комментарии, приведенный выше код будет проверять только положительные целые числа, что охватывает большую часть моего варианта использования. Ниже приведен обновленный код, который правильно проверяет десятичные числа в соответствии с локалью по умолчанию, используемой в вашей системе, с предположением, что десятичный разделитель встречается в строке только один раз.
Изменить :
Обратите внимание: если ваша строка начинается с 0, NumberUtils интерпретирует ваше значение как шестнадцатеричное.
Почему все настаивают на решениях исключений / регулярных выражений?
Здесь я взял регулярное выражение, методы parseNumber () и метод поиска по массиву, чтобы определить, какой из них наиболее эффективен. На этот раз я смотрел только на целые числа.
Результаты по скорости, которые я получил, были:
Отказ от ответственности: я не утверждаю, что эти методы оптимизированы на 100%, они предназначены только для демонстрации данных
Интересно, что простой if char 9 было чрезвычайно просто писать, легко запоминать (и работать на нескольких языках), и он побеждает почти во всех тестовых сценариях.
Для тех, кто задается вопросом, почему я сказал, что легко запомнить массив символов 1, если вы знаете, что нет отрицательных знаков, вы можете легко уйти от чего-то сжатого, например:
Наконец, в качестве заключительного замечания, мне было любопытно узнать об операторе присваивания в принятом примере со всеми поданными голосами. Добавление в присвоение
Не только бесполезен, поскольку вы даже не используете это значение, но и тратит время обработки и увеличивает время выполнения на несколько наносекунд (что привело к увеличению тестов на 100-200 мс). Я не понимаю, зачем кому-то это делать, ведь на самом деле это лишняя работа по снижению производительности.
РЕДАКТИРОВАТЬ: обновлен тест для Character.isDigit ()
Регулярное выражение CraigTP (показанное выше) дает несколько ложных срабатываний. Например. «23y4» будет засчитано как число, потому что ‘.’ соответствует любому символу, кроме десятичной точки.
Также он отклонит любое число с начальным знаком «+»
Альтернативой, позволяющей избежать этих двух незначительных проблем, является
Мы можем попробовать заменить все числа в данной строке на («»), то есть на пробел, и если после этого длина строки равна нулю, то мы можем сказать, что данная строка содержит только числа. Пример: