как проверить что строка это число 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.
Проверьте, является ли строка числовой в Java
Изучите различные способы определения того, является ли строка числовой или нет.
1. введение
Часто при работе с String s нам нужно выяснить, является ли String допустимым числом или нет.
В этом уроке мы рассмотрим несколько способов определить, является ли данная строка числовой , сначала с помощью простой Java, затем регулярных выражений и, наконец, с помощью внешних библиотек.
Как только мы закончим обсуждение различных реализаций, мы будем использовать тесты, чтобы получить представление о том, какие методы являются оптимальными.
Дальнейшее чтение:
Преобразования строк Java
Руководство По API Регулярных Выражений Java
Понимание исключения NumberFormatException в Java
2. Предварительные условия
Давайте начнем с некоторых предварительных условий, прежде чем перейдем к основному содержанию.
В последней части этой статьи мы будем использовать внешнюю библиотеку Apache Commons, чтобы добавить ее зависимость в ваш pom.xml :
3. Использование простой Java
Возможно, самый простой и надежный способ проверить, является ли строка числовой или нет,-это проанализировать ее с помощью встроенных методов Java:
Давайте посмотрим на этот метод в действии:
Эти методы также обсуждаются в статье Преобразования строк Java.
4. Использование Регулярных Выражений
Само собой разумеется, что мы определенно можем изменить это регулярное выражение, чтобы идентифицировать и обрабатывать широкий спектр правил. Здесь все будет просто.
Давайте разберем это регулярное выражение и посмотрим, как оно работает:
А пока давайте создадим метод, используя приведенное выше регулярное выражение:
Теперь давайте рассмотрим некоторые утверждения для приведенного выше метода:
5. Использование Apache Commons
В этом разделе мы обсудим различные методы, доступные в библиотеке Apache Commons.
5.1. NumberUtils.isCreatable(Строка)
NumberUtils из Apache Commons предоставляет статический метод NumberUtils.isCreatable(String) , который проверяет, является ли строка допустимым номером Java или нет.
Этот метод принимает:
Давайте проведем несколько тестов, используя этот метод:
Обратите внимание, что мы получаем истинные утверждения для шестнадцатеричных чисел, восьмеричных чисел и научных обозначений в строках 6, 7 и 8 соответственно.
5.2. Количество элементов.isParsable(Строка)
NumberUtils.Метод isParsable(String) проверяет, является ли данная Строка анализируемой или нет.
Давайте рассмотрим некоторые утверждения:
Мы можем использовать этот метод в качестве замены того, что мы делали в разделе 3, где мы пытаемся проанализировать число и проверить наличие ошибки.
5.3. StringUtils.IsNumeric(CharSequence)
Метод StringUtils.IsNumeric(CharSequence) строго проверяет наличие цифр в Юникоде. Это означает:
Теперь давайте посмотрим на этот метод в действии:
Обратите внимание, что входные параметры в строках 2 и 3 представляют собой числа 123 на арабском и деванагари, соответственно. Поскольку они являются допустимыми цифрами Юникода, этот метод возвращает true для них.
5.4. StringUtils.isNumericSpace(CharSequence)
6. Контрольные показатели
Прежде чем мы завершим эту статью, давайте рассмотрим некоторые результаты тестирования, которые помогут нам проанализировать, какой из вышеупомянутых методов лучше всего подходит для нашего варианта использования.
6.1. Простой бенчмарк
Как мы видим, наиболее дорогостоящими операциями являются регулярные выражения. После этого – наше основное решение на основе Java.
Кроме того, обратите внимание, что операции с использованием библиотеки Apache Commons по большому счету одинаковы.
6.2. Усовершенствованный контрольный показатель
Давайте используем более разнообразный набор тестов для более репрезентативного эталона:
После выполнения тех же тестов мы увидим результаты:
Самое важное различие заключается в том, что два наших теста, решение для регулярных выражений и основное решение на основе Java, поменялись местами.
Кроме того, мы можем с уверенностью заключить, что для оптимальной производительности следует использовать методы из библиотеки Commons или метод, реализованный аналогичным образом.
7. Заключение
В этой статье мы рассмотрели различные способы определения того, является ли строка числовой или нет. Мы рассмотрели оба решения – встроенные методы и внешние библиотеки.
Проверить, является ли строка числовой в Java
1. Вступление
Часто при работе с _Strings нам нужно выяснить, является ли String _ допустимым числом или нет.
После того, как мы закончили обсуждение различных реализаций, мы будем использовать тесты, чтобы понять, какие методы являются оптимальными.
Давайте начнем с некоторых предварительных условий, прежде чем перейти к основному содержанию.
2. Предпосылкой
В последней части этой статьи мы будем использовать внешнюю библиотеку Apache Commons. Чтобы включить эту зависимость, добавьте следующие строки в pom.xml :
3. Использование простой Java
, new BigInteger (String)
Давайте посмотрим на этот метод в действии:
Эти методы также обсуждаются в ссылке:/java-string-conversions[Java String Conversions].
3.1. Проверка входов с помощью Scanner
Например, следующие API проверяют, имеет ли ввод тип integer, long или float :
scanner.hasNextInt ()
scanner.hasNextLong ()
scanner.hasNextFloat ()
Эти API возвращают простые true или false в зависимости от типов ввода. Мы можем использовать эти API, чтобы убедиться, что следующий ввод имеет желаемый тип.
Следующий фрагмент проверяет, является ли ввод целым числом или нет:
Точно так же мы можем использовать другие API для проверки других типов.
4. Использование регулярных выражений
Но само собой разумеется, что мы можем определенно изменить это регулярное выражение, чтобы определить и справиться с широким спектром правил. Здесь мы сделаем это просто.
Давайте разберем это регулярное выражение и посмотрим, как оно работает:
мы ищем одну или несколько цифр, за которыми следует точка. Знак вопроса, в конце концов, означает, что эта полная группа является необязательной.
А пока давайте создадим метод, используя приведенное выше регулярное выражение:
Давайте теперь посмотрим на некоторые утверждения для вышеуказанного метода:
5. Использование Apache Commons
В этом разделе мы обсудим различные методы, доступные в библиотеке Apache Commons.
5.1. NumberUtils.isCreatable (String)
Этот метод принимает:
, Шестнадцатеричные числа, начинающиеся с 0x или 0X
, Восьмеричные числа, начинающиеся с 0
, Научная нотация (например, 1.05e-10)
, Числа, помеченные квалификатором типа (например, 1L или 2.2d)
Если предоставленная строка _null или empty/blank , то она не считается числом, и этот метод вернет false _ в этом случае
Давайте запустим несколько тестов, используя этот метод:
Обратите внимание, как мы получаем _true _ утверждения для шестнадцатеричных чисел, восьмеричных чисел и научных обозначений в строках 6, 7 и 8 соответственно.
Также в строке 14 строка _ «09» turns false because предыдущего «0» указывает, что это восьмеричное число, а «09» _ не является действительным восьмеричным числом.
5.2. NumberUtils.isParsable (String)
Метод _https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/math/NumberUtils.html#isParsable-java.lang.String-[NumberUtils.isParsable (String)] проверяет, является ли данная String _ анализируемой или нет.
Давайте посмотрим на некоторые утверждения:
Мы можем использовать этот метод в качестве замены того, что мы делали в разделе 3, где мы пытаемся проанализировать число и проверить наличие ошибки.
5.3. _StringUtils.isNumeric (CharSequence ) ___
Метод _https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/StringUtils.html#isNumeric-java.lang.CharSequence-[StringUtils.isNumeric (CharSequence)] _ строго проверяет для цифр Юникода. Это означает:
, Любые цифры с любого языка, которые являются цифрами Unicode, являются приемлемыми
, Так как десятичная точка не считается цифрой Unicode, это не
Давайте теперь посмотрим на этот метод в действии:
Обратите внимание, что входные параметры в строках 2 и 3 представляют числа __123 на арабском и деванагари соответственно. Так как они являются действительными цифрами Unicode, этот метод возвращает true __onon.
5.4. StringUtils.isNumericSpace (CharSequence)
6. Ориентиры
Прежде чем мы завершим эту статью, давайте кратко рассмотрим результаты тестов, которые помогут нам проанализировать, какие из перечисленных методов являются оптимальными:
Как мы видим, наиболее дорогостоящая операция с регулярными выражениями, за которой следует базовое решение на основе Java. Все остальные операции, использующие библиотеку Apache Commons, в целом одинаковы.
7. Заключение
Как проверить, является ли строка числовой в 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» будет засчитано как число, потому что ‘.’ соответствует любому символу, кроме десятичной точки.
Также он отклонит любое число с начальным знаком «+»
Альтернативой, позволяющей избежать этих двух незначительных проблем, является
Мы можем попробовать заменить все числа в данной строке на («»), то есть на пробел, и если после этого длина строки равна нулю, то мы можем сказать, что данная строка содержит только числа. Пример:
Как проверить, является ли String числовым в Java
Как бы вы проверили, была ли строка числом до ее разбора?
Обычно это делается с помощью простой пользовательской функции (т.е. функция Roll-your-own «isNumeric»).
Однако, если вы вызываете эту функцию много, и вы ожидаете, что многие из проверок будут терпеть неудачу из-за того, что не будет числа, производительность этого механизма будет невелика, поскольку вы полагаетесь на исключения, которые бросаются на каждый сбой, что является довольно дорогостоящей операцией.
Альтернативным подходом может быть использование регулярного выражения для проверки действительности числа:
Однако будьте осторожны с вышеупомянутым механизмом RegEx, поскольку он будет терпеть неудачу, если вы используете неарабские цифры (например, цифры, отличные от 0 до 9). Это связано с тем, что часть «\ d» RegEx будет соответствовать только 2 и эффективно не воспринимается на международном уровне. (Спасибо OregonGhost за это!)
Вы также можете использовать StringUtils.isNumericSpace который возвращает true для пустых строк и игнорирует внутренние пробелы в строке. Другим способом является использование StringUtils.isParsable который в основном проверяет, является ли число StringUtils.isParsable для StringUtils.isParsable в соответствии с Java. (Связанные javadocs содержат подробные примеры для каждого метода.)
если вы находитесь на android, вы должны использовать:
ОБНОВЛЕНИЕ: Как указал Жан-Франсуа Корбетт в комментарии, вышеуказанный код будет только проверять положительные целые числа, которые охватывают большинство моих вариантов использования. Ниже приведен обновленный код, который корректно проверяет десятичные числа в соответствии с языковой установкой по умолчанию, используемой в вашей системе, с предположением, что разделитель десятичных знаков встречается только один раз в строке.
Ява-выражения Java 8.
Не используйте исключения для проверки ваших значений. Используйте Util libs вместо apache NumberUtils:
Изменить:
Обратите внимание, что если ваша строка начинается с 0, NumberUtils будет интерпретировать ваше значение как шестнадцатеричное.
Почему все, кто настаивает на решениях exception/regex?
В то время как я могу понять, что большинство людей отлично справляются с использованием try/catch, если вы хотите часто это делать. это может быть чрезвычайно облагаемым налогом.
То, что я здесь делал, это взять регулярное выражение, методы parseNumber() и метод поиска массива, чтобы узнать, какой из них наиболее эффективен. На этот раз я только посмотрел на целые числа.
Результаты в скорости, которые я получил, были:
Отказ от ответственности: я не утверждаю, что эти методы на 100% оптимизированы, они просто для демонстрации данных
Исключения выиграны, если и только если число равно 4 символам или меньше, и каждая строка всегда является числом. в этом случае, почему даже есть чек?
Короче говоря, очень сложно, если вы часто сталкиваетесь с недопустимыми числами с помощью try/catch, что имеет смысл. Важным правилом, которым я всегда придерживаюсь, является НИКОГДА не использовать try/catch для потока программы. Это пример.
Интересно, что простой, если char 9 было чрезвычайно просто писать, легко запоминаться (и должно работать на нескольких языках) и выигрывает почти все тестовые сценарии.
Единственным недостатком является то, что я предполагаю, что Integer.parseInt() может обрабатывать не ASCII-номера, тогда как метод поиска массива не работает.
Для тех, кто задавался вопросом, почему я сказал, что легко запомнить массив символов, если вы не знаете никаких отрицательных признаков, вы можете легко уйти от чего-то сжатого, как это:
Наконец, в качестве заключительной заметки, мне было интересно узнать оператора-ассистента в принятом примере со всеми голосами. Добавление в присваивание
не только бесполезен, поскольку вы даже не используете его, но он тратит время обработки и увеличивает время выполнения на несколько наносекунд (что привело к увеличению тестов на 100-200 мс). Я не понимаю, почему кто-то это сделает, поскольку на самом деле это дополнительная работа для снижения производительности.
Вы подумали бы, что это будет оптимизировано. хотя, возможно, я должен проверить байт-код и посмотреть, что делает компилятор. Это не объясняет, почему это всегда показалось мне более длинным, хотя если оно каким-то образом оптимизировано. поэтому я задаюсь вопросом, что происходит. В качестве примечания: по длине я имею в виду запуск теста для 10000000 итераций, и запуск этой программы несколько раз (10x +) всегда показывал, что она медленнее.