Как проверить что строка это число java

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

Также можно воспользоваться методом StringUtils.isNumeric() :

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

Приведенный ниже метод isNumber() проверит является ли строка числом :

Рекомендуемые курсы

Похожие вопросы

ООО «Хекслет Рус» 432071, г. Ульяновск, пр-т Нариманова, дом 1Г, оф. 23 ОГРН 1217300010476

Java: Check if String is a Number

Strings are a handy way of getting information across and getting input from a user.

In this article, we will go through a couple of ways check if a String is Numeric in Java — that is to say, if a String represents a numeric value.

Check if String is Numeric with Core Java

Users tend to mistype input values fairly often, which is why developers have to hold their hand as much as possible during IO operations.

The easiest way of checking if a String is a numeric or not is by using one of the following built-in Java methods:

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

These methods convert a given String into its numeric equivalent. If they can't convert it, a NumberFormatException is thrown, indicating that the String wasn't numeric.

It's worth noting that Integer.valueOf() returns a new Integer() , while Integer.parseInt() returns a primitive int . Keep this in mind if such a difference would change the flow of your program.

Let's try this out:

This results in:

Now, we can abstract this functionality into a helper method for convenience:

Now, we can simply call:

Running this code would result in:

On the other hand, if we expect the String to contain a really big number, then we can call the BigInteger(String) constructor, which translates the String representation into a BigInteger .

Check if String is Numeric with Apache Commons

Apache Commons is one of the most used third-party libraries for expanding the basic Java Framework. It gives us more fine control over core Java classes, in this case, Strings.

We'll be looking at two classes from the Apache Commons library:

1. NumberUtils
2. StringUtils

Both of which are very similar to their vanilla Java class counterparts, but with an emphasis on null-safe operations (on numbers and strings respectively), meaning we can even define default values for missing (null) values.

Let's now take a look at how we can check for numeric values using these methods.

NumberUtils.isParsable()

This method accepts a String and checks if it's a parsable number or not, we can be use this method instead of catching an exception when calling one of the methods we mentioned earlier.

Free eBook: Git Essentials

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

This is very good because solutions that involve frequent exception handling should be avoided if possible — this is exactly what this method helps us with.

Note that hexadecimal numbers and scientific notations are not considered parsable.

Now, we don't really even need a convenience helper method, as isParseable() returns a boolean itself:

This code should return:

NumberUtils.isCreatable()

This method also accepts a String and checks if it's a valid Java number. With this method we can cover even more numbers, because a valid Java number includes even hexadecimal and octal numbers, scientific notation, as well as numbers marked with a type qualifier.

Now, we can even use something along the lines of:

The output would be:

NumberUtils.isDigits()

The NumberUtils.isDigits() method checks if a string contains only Unicode digits. If the String contains a leading sign or decimal point the method will return false :

StringUtils.isNumeric()

The StringUtils.isNumeric() is the StringUtils equivalent of NumberUtils.isDigits() .

If the String passes the numeric test, it may still generate a NumberFormatException error when parsed by the methods we mentioned earlier, for example if it is out of range for int or long .

Using this method we can determine if we can parse String into an Integer :

StringUtils.isNumericSpace()

Additionally, if we expect to find more numbers within a String, we can use isNumericSpace , another useful StringUtils method worth mentioning. It checks if the String contains only Unicode digits or spaces.

Let's check a String that contains numbers and spaces:

This results in:

Check if String is Numeric with Regex

Even though most developers will be content with using an already implemented method, sometimes you might have very specific pattern checking:

And then, we can call this method:

Running this gives us the following output:

Conclusion

In this article, we've covered several ways to check if a String is numeric or not (represents a number) in Java.

We've started off using Core Java, and catching a NumberFormatException , after which we've used the Apache Commons library. From there, we've utilized the StringUtils and NumberUtils classes to check whether a String is numeric or not, with various formats.

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

Часто при работе с _Strings нам нужно выяснить, является ли String _ допустимым числом или нет.

В этом руководстве мы рассмотрим несколько способов определения, является ли данная _Строка _ числовой ** , сначала с использованием простой Java, затем регулярных выражений и, наконец, с использованием внешних библиотек.

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

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

2. Предпосылкой

В последней части этой статьи мы будем использовать внешнюю библиотеку Apache Commons. Чтобы включить эту зависимость, добавьте следующие строки в pom.xml :

3. Использование простой Java

Пожалуй, самый простой и надежный способ проверить, является ли _String _ числовым или нет, — это проанализировать его с помощью встроенных методов Java:

, new BigInteger (String)

Если эти методы не выдают NumberFormatException , то это означает, что синтаксический анализ был успешным и __String __is числовой:

Давайте посмотрим на этот метод в действии:

В нашем _isNumeric () method мы просто проверяем значения типа Double , но этот метод также можно изменить, чтобы проверять Integer , Float , Long _ и большие числа, используя любой из методов синтаксического анализа, которые мы зачислили ранее ,

Эти методы также обсуждаются в ссылке:/java-string-conversions[Java String Conversions].

3.1. Проверка входов с помощью Scanner

java.util ‘s Scanner class, пожалуй, самый простой способ в простой Java для получения примитивных типов входных данных, таких как int , double и т. д. Он также предоставляет различные API-интерфейсы для проверки, является ли данный вход определенного типа или нет.

Например, следующие API проверяют, имеет ли ввод тип integer, long или float :

scanner.hasNextInt ()

scanner.hasNextLong ()

scanner.hasNextFloat ()

Эти API возвращают простые true или false в зависимости от типов ввода. Мы можем использовать эти API, чтобы убедиться, что следующий ввод имеет желаемый тип.

Следующий фрагмент проверяет, является ли ввод целым числом или нет:

Точно так же мы можем использовать другие API для проверки других типов.

4. Использование регулярных выражений

Теперь давайте использовать регулярное выражение _-? \ D (\. \ D)? для сопоставления числовых Strings _ , состоящих из положительного или отрицательного целого числа и чисел с плавающей точкой.

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

Давайте разберем это регулярное выражение и посмотрим, как оно работает:

-? — эта часть определяет, является ли данное число отрицательным, тире

« – » Буквально ищет тире, а вопросительный знак « ? » Обозначает его присутствие в качестве дополнительного ** \ d — поиск одной или нескольких цифр

(\. \ d)? — эта часть регулярного выражения предназначена для определения чисел с плавающей точкой. Вот

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

Регулярные выражения — это очень широкая тема, и чтобы получить краткий обзор, перейдите по ссылке:/регулярные-выражения-java[эта связанная статья Baeldung]

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

Давайте теперь посмотрим на некоторые утверждения для вышеуказанного метода:

5. Использование Apache Commons

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

5.1. NumberUtils.isCreatable (String)

_https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/math/NumberUtils.html[NumberUtils] из Apache Commons предоставляет статический метод https://commons.apache . org/Proper/commons-lang/apidocs/org/apache/commons/lang3/math/NumberUtils.html # isCreatable-java.lang.String-[NumberUtils.isCreatable (String)] , который проверяет, является ли _ действительным номер Java или не.

Этот метод принимает:

, Шестнадцатеричные числа, начинающиеся с 0x или 0X

, Восьмеричные числа, начинающиеся с 0

, Научная нотация (например, 1.05e-10)

, Числа, помеченные квалификатором типа (например, 1L или 2.2d)

Если предоставленная строка _null или empty/blank , то она не считается числом, и этот метод вернет false _ в этом случае

Давайте запустим несколько тестов, используя этот метод:

Обратите внимание, как мы получаем _true _ утверждения для шестнадцатеричных чисел, восьмеричных чисел и научных обозначений в строках 6, 7 и 8 соответственно.

Также в строке 14 строка _ «09» turns false because предыдущего «0» указывает, что это восьмеричное число, а «09» _ не является действительным восьмеричным числом.

Для каждого ввода, которое возвращает _true с помощью этого метода, мы можем использовать https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/math/NumberUtils.html#createNumber-java.lang .String -[ NumberUtils.createNumber (String) _ ], который даст нам правильный номер.

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 _ анализируемой или нет.

Разборные числа — это те, которые успешно анализируются любым методом разбора, например Integer.parseInt (String) , Long.parseLong (String) , _Float.parseFloat (String) or Double.parseDouble (String) _ . **

В отличие от NumberUtils.isCreatable () , этот метод не принимает шестнадцатеричные числа, научные записи или строки, заканчивающиеся любым квалификатором типа, например _ ‘f’, ‘F’, ‘d’, ‘D’, ‘l’ or ‘ L»._

Давайте посмотрим на некоторые утверждения:

В строке 4, в отличие от NumberUtils.isCreatable () , число, начинающееся со строки _ «0» _ , не считается восьмеричным числом, но является нормальным десятичным числом и, следовательно, возвращает значение true.

Мы можем использовать этот метод в качестве замены того, что мы делали в разделе 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)

Https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/StringUtils.html#isNumericSpace-java.lang.CharSequence-[ StringUtils.isNumericSpace(CharSequence) ]проверяет строго для цифр Юникод и/или пробела. Это то же самое, что и _StringUtils.isNumeric () _ , с той лишь разницей, что он также принимает пробелы, не только начальные и конечные пробелы, но также, если они находятся между числами:

6. Ориентиры

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

Как мы видим, наиболее дорогостоящая операция с регулярными выражениями, за которой следует базовое решение на основе Java. Все остальные операции, использующие библиотеку Apache Commons, в целом одинаковы.

7. Заключение

В этой статье мы исследовали различные способы выяснить, является ли _String _ числовым или нет. Мы рассмотрели оба решения — встроенные методы, а также внешние библиотеки.

Как всегда, реализацию всех приведенных выше примеров и фрагментов кода, включая код, используемый для выполнения тестов, можно найти по адресу over на GitHub .

Rukovodstvo

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

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

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

Время чтения: 5 мин.

Вступление

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

В этой статье мы рассмотрим несколько способов проверить, является ли 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 будет содержать действительно большое число, мы можем вызвать конструктор BigInteger(String) , который переводит представление String BigInteger .

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

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

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

1. NumberUtils
2. StringUtils

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

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

NumberUtils.isParsable ()

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

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

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

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

Этот код должен вернуть:

NumberUtils.isCreatable ()

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

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

NumberUtils.isDigits ()

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

StringUtils.isNumeric ()

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

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

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

StringUtils.isNumericSpace ()

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

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

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

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

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

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

Заключение

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

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