как проверить что в строке только цифры java
Проверьте, содержит ли строка числа Java
Я пишу программу, в которой пользователь вводит строку в следующем формате:
что я могу использовать в качестве решения для поиска и извлечение?
14 ответов
Если вы хотите извлечь первое число из входной строки, вы можете сделать-
для ввода «123abc», метод выше будет возвращать 123.
для «abc1000def», 1000.
для «abc», вернет пустую строку.
s=s.replaceAll(«[*a-zA-Z]», «») заменяет все буквы
s=s.replaceAll(«[*0-9]», «») заменяет все цифры
если вы сделаете выше двух замен, вы получите все специальные символьные строки
если вы хотите извлечь только целые числа из String s=s.replaceAll(«[^0-9]», «»)
если вы хотите извлечь только буквы от String s=s.replaceAll(«[^a-zA-Z]», «»)
удачи в кодировании 🙂
Я не смог найти ни одного правильного шаблона. Пожалуйста, следуйте ниже руководство для небольшого и сладкого решения.
приведенного ниже кода достаточно для «проверить, содержит ли строка числа в Java»
попробуйте следующий шаблон:
решение, с которым я пошел, выглядит так:
Я уверен, что это не идеальное решение, но это подходит моим потребностям. Спасибо всем за помощь. 🙂
вы можете попробовать это
поскольку вы не только хотите искать число, но и извлекать его, вы должны написать небольшую функцию, делая это за вас. Иди буква за буквой, пока не найдешь цифру. Ах, только что нашел для вас необходимый код на stackoverflow:найти целое число в строку. Посмотрите на принятый ответ.
.matches(«.*\d+.*») работает только для чисел, но не для других символов, таких как // или * etc.
ASCII находится в начале UNICODE, поэтому вы можете сделать что-то вроде этого:
Я уверен, что вы можете выяснить другие ценности.
Как определить, является ли строка числом?
Я делал так, но мне кажется такой подход в чем-то неправильным:
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 String-посмотрите, содержит ли строка только числа, а не буквы
у меня есть строка, которую я загружаю во всем своем приложении, и она меняется с чисел на буквы и тому подобное. У меня простой if оператор, чтобы увидеть, содержит ли он буквы или цифры, но что-то не совсем работает правильно. Вот фрагмент.
устранение:
я смог решить эту проблему, используя следующий код, предоставленный комментарием к этому вопросу. Все остальные сообщения также действительны!
то, что я использовал, что сработало, пришло из первого комментария. Хотя все приведенные примеры кодов, по-видимому, также действительны!
16 ответов
если вы будете обрабатывать числа как текст, а затем изменить:
вместо того, чтобы проверить, что строка не содержат алфавитные символы, убедитесь, что он содержит только числа.
если вы действительно хотите использовать числовое значение, используйте Integer.parseInt() или Double.parseDouble() как уже объяснили ниже.
вы также можете использовать NumberUtil.isCreatable (String str) из Apache Commons
вот как я бы это сделал:
производительность-мудрый parseInt и они намного хуже, чем другие решения, потому что, по крайней мере, требуют обработки исключений.
Я запустил тесты jmh и обнаружил, что итерация по строке с помощью charAt и сравнение символов с граничными символами-самый быстрый способ проверить, содержит ли строка только цифры.
тестирование JMH
тесты сравнения производительности Character.isDigit vs Pattern.matcher().matches vs Long.parseLong vs проверка значений char.
тесты выполняются в режиме пропускной способности (больше лучше) С 5 итерациями разминки и 5 итерациями теста.
результаты
отметим, что parseLong почти в 100 раз медленнее, чем isDigit для первого теста.
тесты
Обновлено 23 февраля 2018
Обновлено 23 февраля 2018
есть много возможностей для получения номера от String s в Java (и наоборот). Возможно, вы захотите пропустить часть regex, чтобы избавить себя от этого усложнения.
например, вы можете попробовать и посмотреть, что Double.parseDouble(String s) возвращает для вас. Он должен бросить NumberFormatException если он не находит соответствующего значения в строке. Я бы предложил этот метод, потому что вы могли бы использовать значение, представленное String Как числовой тип.
вы можете использовать регулярное выражение.Матч
или вы можете использовать onversions как Integer.parseInt(String) или лучше Long.parseLong(String) для больших чисел например:
а затем проверить с:
другие методы этого класса допускают дальнейшие числовые проверки.
чтобы просто проверить строку, которая содержит только алфавиты, используйте следующий код:
чтобы просто проверить строку, которая содержит только номер, используйте следующий код:
надеюсь, это поможет кому-то!
этот код уже написан. Если вы не против (очень) малой производительности-это, вероятно, не хуже, чем regex матча-используйте целое число.parseInt() или двойной.parseDouble(). Это сразу скажет вам, Является ли строка только числами (или это номер, в зависимости от обстоятельств). Если вам нужно обрабатывать более длинные строки чисел, оба BigInteger и BigDecimal спорт конструкторы, которые принимают строки. Любой из эти бросят NumberFormatException Если вы попытаетесь передать ему не-число (интегральное или десятичное, на основе выбранного вами, конечно). Поочередно, в зависимости от ваших требований, просто повторите символы в строке и проверьте символ.isDigit() и/или
ниже regexs можно использовать, чтобы проверить, имеет ли строка только номер или нет:
if (str.matches(«.*[^0-9].*»)) or if (str.matches(«.*\D.*»))
рабочий тестовый пример
все еще ваш код может быть сломан «1a» и т. д., Поэтому вам нужно проверить исключение
метод проверки нет-строка или нет
Это плохая практика, чтобы включить любое исключение бросая / обработки в такой типичный сценарий.
поэтому parseInt () не очень хорош, но регулярное выражение является элегантным решением для этого, но позаботьтесь о следующем:
— дроби
-отрицательные числа
— десятичный разделитель может отличаться в Контри (например,’, ‘ или ‘.’)
— иногда разрешается иметь так называемый тысячный разделитель, например пробел или запятую, например 12,324,1000.355
Как проверить, содержит ли строка только цифры в Java
В Java для класса String существует метод, называемый match, как использовать этот метод, чтобы проверить, имеет ли моя строка только цифры с регулярным выражением. Я пробовал с примерами ниже, но оба они вернули мне ложные результаты.
Согласно регулярным выражениям Java, + означает “один или несколько раз”, а \d означает “цифра”.
Примечание. “Двойная обратная косая черта” является escape-последовательностью для получения одной обратной косой черты, поэтому \\d в строке Java дает фактический результат: \d
Ссылки:
Изменить: из-за некоторой путаницы в других ответах я пишу тестовый пример и подробно объясню некоторые вещи.
Во-первых, если вы сомневаетесь в правильности этого решения (или других), запустите этот тестовый пример:
Вопрос 1:
Нет. В java метод matches (который был указан в вопросе) соответствует полной строке, а не фрагментам. Другими словами, нет необходимости использовать ^\\d+$ (хотя это также правильно). Пожалуйста, посмотрите последний негативный тестовый пример.
Вопрос 2:
Нет. Регулярное выражение \\d* будет соответствовать пустой строке, но \\d+ – нет. Звезда * означает ноль или более, тогда как плюс + означает один или более. Пожалуйста, посмотрите первый отрицательный тестовый пример.
Вопрос 3
Не быстрее ли скомпилировать шаблон регулярных выражений?
Вы также можете использовать NumberUtil.isNumber(String str) из Apache Commons
Еще одно решение, которое еще не было опубликовано:
и исключение catch, оно обрабатывает знак минус.
Несмотря на то, что количество цифр ограничено, это фактически создает переменную данных, которые могут быть использованы, что, я думаю, является наиболее распространенным вариантом использования.
Вы должны разрешить больше цифры (знак + ), как в:
Использование регулярных выражений является дорогостоящим с точки зрения производительности. Попытка разобрать строку как длинное значение неэффективна и ненадежна, и может быть не то, что вам нужно.
Я предлагаю просто проверить, является ли каждый символ цифрой, что можно эффективно выполнить с помощью ямбда-выражений Java 8:
В соответствии с Oracle Java Documentation:
шаблон 9 означает цифру. То же, что и ‘\ d’.
“+” означает, что он появляется больше раз.
” для integer или float.
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.