Получить числа из строки
Есть строка, она содержит числа, допустим, пароль — 450. Как получить это число? Строка может содержать русский текст.
Отслеживать
51.2k 86 86 золотых знаков 266 266 серебряных знаков 505 505 бронзовых знаков
задан 4 ноя 2011 в 21:28
AndroidDev AndroidDev
1,684 2 2 золотых знака 28 28 серебряных знаков 58 58 бронзовых знаков
То есть в строке не только одно число, а что-то еще?
4 ноя 2011 в 21:57
5 ответов 5
Сортировка: Сброс на вариант по умолчанию
import java.util.regex.*; Pattern pat=Pattern.compile("[-]?[0-9]+(.[0-9]+)?"); Matcher matcher=pat.matcher("45.5saf -fg123 -18+"); while (matcher.find()) < System.out.println(matcher.group()); >; Так можно получить все числа из строки.
Результат этого примера 45.5; 123; -18.
Отслеживать
ответ дан 4 ноя 2011 в 22:52
17.9k 3 3 золотых знака 46 46 серебряных знаков 86 86 бронзовых знаков
@ReinRaus, да, ваш код лучше.
4 ноя 2011 в 22:53
Регулярное выражение не верное) например 44..1
6 ноя 2011 в 16:29
Спасибо, исправил.
10 ноя 2011 в 1:59
Вот такой код найдет все числа в строке:
Pattern pattern = Pattern.compile("\\d+"); String word = "test123test444test"; // мой пример строки Matcher matcher = pattern.matcher(word); int start = 0; while (matcher.find(start))
Отслеживать
ответ дан 4 ноя 2011 в 22:45
8,657 18 18 золотых знаков 73 73 серебряных знака 181 181 бронзовый знак
String s1 ="пароль - 450"; String s2 = s1.split("\\\D+"); //s2 - символьный массив всех числовых вхождений. Вопрос старый, но поисковики выводят ее практически первой. Мало ли кому пригодится.
Отслеживать
2,451 1 1 золотой знак 15 15 серебряных знаков 25 25 бронзовых знаков
ответ дан 10 окт 2016 в 19:19
Алексей Анищенко Алексей Анищенко
21 2 2 бронзовых знака
Если знаете структуру строки, можете использовать регулярные выражения.
Отслеживать
51.2k 86 86 золотых знаков 266 266 серебряных знаков 505 505 бронзовых знаков
ответ дан 4 ноя 2011 в 22:31
248 1 1 серебряный знак 7 7 бронзовых знаков
4 ноя 2011 в 22:46
String s1 = "тестовое сообщение 34567"; String[] s2_array = s1.split("\\D+"); Integer numbers = Integer.parseInt(String.join("", s2_array)); Отслеживать
ответ дан 1 фев 2022 в 14:54
1 1 1 бронзовый знак
добро пожаловать на Stack Overflow на русском! пожалуйста, постарайтесь оставлять чуть более развёрнутые ответы. дополнить ответ можно, нажав править
1 фев 2022 в 15:03
-
Важное на Мете
Похожие
Подписаться на ленту
Лента вопроса
Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.
Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.11.15.1019
Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.
Как из строки получить число java
Для соединения строк можно использовать операцию сложения («+»):
String str1 = "Java"; String str2 = "Hello"; String str3 = str1 + " " + str2; System.out.println(str3); // Hello Java
При этом если в операции сложения строк используется нестроковый объект, например, число, то этот объект преобразуется к строке:
String str3 = "Год " + 2015;
Фактически же при сложении строк с нестроковыми объектами будет вызываться метод valueOf() класса String. Данный метод имеет множество перегрузок и преобразует практически все типы данных к строке. Для преобразования объектов различных классов метод valueOf вызывает метод toString() этих классов.
Другой способ объединения строк представляет метод concat() :
String str1 = "Java"; String str2 = "Hello"; str2 = str2.concat(str1); // HelloJava
Метод concat() принимает строку, с которой надо объединить вызывающую строку, и возвращает соединенную строку.
Еще один метод объединения — метод join() позволяет объединить строки с учетом разделителя. Например, выше две строки сливались в одно слово «HelloJava», но в идеале мы бы хотели, чтобы две подстроки были разделены пробелом. И для этого используем метод join() :
String str1 = "Java"; String str2 = "Hello"; String str3 = String.join(" ", str2, str1); // Hello Java
Метод join является статическим. Первым параметром идет разделитель, которым будут разделяться подстроки в общей строке, а все последующие параметры передают через запятую произвольный набор объединяемых подстрок — в данном случае две строки, хотя их может быть и больше
Извлечение символов и подстрок
Для извлечения символов по индексу в классе String определен метод char charAt(int index) . Он принимает индекс, по которому надо получить символов, и возвращает извлеченный символ:
String str = "Java"; char c = str.charAt(2); System.out.println(c); // v
Как и в массивах индексация начинается с нуля.
Если надо извлечь сразу группу символов или подстроку, то можно использовать метод getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) . Он принимает следующие параметры:
- srcBegin : индекс в строке, с которого начинается извлечение символов
- srcEnd : индекс в строке, до которого идет извлечение символов
- dst : массив символов, в который будут извлекаться символы
- dstBegin : индекс в массиве dst, с которого надо добавлять извлеченные из строки символы
String str = "Hello world!"; int start = 6; int end = 11; char[] dst=new char[end - start]; str.getChars(start, end, dst, 0); System.out.println(dst); // world
Сравнение строк
Для сравнения строк используются методы equals() (с учетом регистра) и equalsIgnoreCase() (без учета регистра). Оба метода в качестве параметра принимают строку, с которой надо сравнить:
String str1 = "Hello"; String str2 = "hello"; System.out.println(str1.equals(str2)); // false System.out.println(str1.equalsIgnoreCase(str2)); // true
В отличие от сравнения числовых и других данных примитивных типов для строк не применяется знак равенства ==. Вместо него надо использовать метод equals() .
Еще один специальный метод regionMatches() сравнивает отдельные подстроки в рамках двух строк. Он имеет следующие формы:
boolean regionMatches(int toffset, String other, int oofset, int len) boolean regionMatches(boolean ignoreCase, int toffset, String other, int oofset, int len)
Метод принимает следующие параметры:
- ignoreCase : надо ли игнорировать регистр символов при сравнении. Если значение true , регистр игнорируется
- toffset : начальный индекс в вызывающей строке, с которого начнется сравнение
- other : строка, с которой сравнивается вызывающая
- oofset : начальный индекс в сравниваемой строке, с которого начнется сравнение
- len : количество сравниваемых символов в обеих строках
String str1 = "Hello world"; String str2 = "I work"; boolean result = str1.regionMatches(6, str2, 2, 3); System.out.println(result); // true
В данном случае метод сравнивает 3 символа с 6-го индекса первой строки («wor») и 3 символа со 2-го индекса второй строки («wor»). Так как эти подстроки одинаковы, то возвращается true .
И еще одна пара методов int compareTo(String str) и int compareToIgnoreCase(String str) также позволяют сравнить две строки, но при этом они также позволяют узнать больше ли одна строка, чем другая или нет. Если возвращаемое значение больше 0, то первая строка больше второй, если меньше нуля, то, наоборот, вторая больше первой. Если строки равны, то возвращается 0.
Для определения больше или меньше одна строка, чем другая, используется лексикографический порядок. То есть, например, строка «A» меньше, чем строка «B», так как символ ‘A’ в алфавите стоит перед символом ‘B’. Если первые символы строк равны, то в расчет берутся следующие символы. Например:
String str1 = "hello"; String str2 = "world"; String str3 = "hell"; System.out.println(str1.compareTo(str2)); // -15 - str1 меньше чем strt2 System.out.println(str1.compareTo(str3)); // 1 - str1 больше чем str3
Поиск в строке
Метод indexOf() находит индекс первого вхождения подстроки в строку, а метод lastIndexOf() — индекс последнего вхождения. Если подстрока не будет найдена, то оба метода возвращают -1:
String str = "Hello world"; int index1 = str.indexOf('l'); // 2 int index2 = str.indexOf("wo"); //6 int index3 = str.lastIndexOf('l'); //9
Метод startsWith() позволяют определить начинается ли строка с определенной подстроки, а метод endsWith() позволяет определить заканчивается строка на определенную подстроку:
String str = "myfile.exe"; boolean start = str.startsWith("my"); //true boolean end = str.endsWith("exe"); //true
Замена в строке
Метод replace() позволяет заменить в строке одну последовательность символов на другую:
String str = "Hello world"; String replStr1 = str.replace('l', 'd'); // Heddo wordd String replStr2 = str.replace("Hello", "Bye"); // Bye world
Обрезка строки
Метод trim() позволяет удалить начальные и конечные пробелы:
String str = " hello world "; str = str.trim(); // hello world
Метод substring() возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса:
String str = "Hello world"; String substr1 = str.substring(6); // world String substr2 = str.substring(3,5); //lo
Изменение регистра
Метод toLowerCase() переводит все символы строки в нижний регистр, а метод toUpperCase() — в верхний:
String str = "Hello World"; System.out.println(str.toLowerCase()); // hello world System.out.println(str.toUpperCase()); // HELLO WORLD
Split
Метод split() позволяет разбить строку на подстроки по определенному разделителю. Разделитель — какой-нибудь символ или набор символов передается в качестве параметра в метод. Например, разобьем текст на отдельные слова:
String text = «FIFA will never regret it»; String[] words = text.split(» «); for(String word : words)
В данном случае строка будет разделяться по пробелу. Консольный вывод:
FIFA will never regret it
24) Преобразовать строку Java в целое число
Допустим, у вас есть строка strTest, которая содержит числовое значение.
String strTest = “100”;
Попробуйте выполнить некоторую арифметическую операцию, такую как деление на 4 – это немедленно покажет вам ошибку компиляции.
class StrConvert < public static void main(String []args)< String strTest = "100"; System.out.println("Using String:" + (strTest/4)); >>
Вывод:
/StrConvert.java:4: error: bad operand types for binary operator '/' System.out.println("Using String:" + (strTest/4));
Следовательно, вам нужно преобразовать String в int, прежде чем выполнять над ним числовые операции.
Пример 1. Преобразование строки в целое число с использованием Integer.parseInt ()
Синтаксис метода parseInt выглядит следующим образом:
int = Integer.parseInt();
Передайте строковую переменную в качестве аргумента.
Это преобразует Java String в Java Integer и сохраняет его в указанной целочисленной переменной.
Проверьте фрагмент кода ниже
class StrConvert < public static void main(String []args)< String strTest = "100"; int iTest = Integer.parseInt(strTest); System.out.println("Actual String:"+ strTest); System.out.println("Converted to Int:" + iTest); //This will now show some arithmetic operation System.out.println("Arithmetic Operation on Int: " + (iTest/4)); >>
Вывод:
Actual String:100 Converted to Int:100 Arithmetic Operation on Int: 25
Пример 2. Преобразование строки в целое число с использованием Integer.valueOf ()
Метод Integer.valueOf () также используется для преобразования String в Integer в Java.
Ниже приведен пример кода, демонстрирующий процесс использования метода Integer.valueOf ():
public class StrConvert < public static void main(String []args)< String strTest = "100"; //Convert the String to Integer using Integer.valueOf int iTest = Integer.valueOf(strTest); System.out.println("Actual String:"+ strTest); System.out.println("Converted to Int:" + iTest); //This will now show some arithmetic operation System.out.println("Arithmetic Operation on Int:" + (iTest/4)); >>
Вывод:
Actual String:100 Converted to Int:100 Arithmetic Operation on Int:25
NumberFormatException
NumberFormatException генерируется, если вы пытаетесь проанализировать недопустимую числовую строку. Например, строка «Guru99» не может быть преобразована в целое число.
public class StrConvert < public static void main(String []args)< String strTest = "Guru99"; int iTest = Integer.valueOf(strTest); System.out.println("Actual String:"+ strTest); System.out.println("Converted to Int:" + iTest); >>
Приведенный выше пример дает следующее исключение в выводе:
Exception in thread "main" java.lang.NumberFormatException: For input string: "Guru99"
Rukovodstvo
статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.
Java: проверьте, является ли строка числом
Введение Строки — это удобный способ передачи информации и получения ввода от пользователя. В этой статье мы рассмотрим несколько способов проверки того, является ли String числовым в Java, то есть представляет ли String числовое значение. Проверьте, является ли строка числовой с помощью Core Java. Пользователи часто ошибаются при вводе значений, поэтому разработчики должны как можно дольше держать их за руку во время операций ввода-вывода. Самый простой способ проверить, является ли строка числовой или нет, принадлежит нам.
Время чтения: 5 мин.
Вступление
Строки — это удобный способ передачи информации и получения ввода от пользователя.
В этой статье мы рассмотрим несколько способов проверить, является ли String числовым в Java, то есть представляет ли String числовое значение.
Проверьте, является ли строка числовой с помощью Core Java
Пользователи часто ошибочно набирают входные значения, поэтому разработчики должны как можно дольше держать их за руку во время операций ввода-вывода.
Самый простой способ проверить, является ли String числовым или нет, — использовать один из следующих встроенных методов Java:
- Integer.parseInt()
- Integer.valueOf()
- Double.parseDouble()
- Float.parseFloat()
- Long.parseLong()
Эти методы преобразуют заданную String в ее числовой эквивалент. Если они не могут его преобразовать, NumberFormatException , указывающее, что строка не является числовой.
Стоит отметить, что Integer.valueOf() возвращает new Integer() , а Integer.parseInt() возвращает примитивный int . Имейте это в виду, если такая разница изменит ход вашей программы.
Давайте попробуем это:
String string = "10"; try < intValue = Integer.parseInt(string); return true; >catch (NumberFormatException e)
true
Теперь для удобства мы можем абстрагировать эту функциональность во вспомогательный метод:
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:
- NumberUtils
- StringUtils
Оба из них очень похожи на свои аналоги в классическом Java-классе, но с акцентом на нулевые безопасные операции (с числами и строками соответственно), что означает, что мы можем даже определять значения по умолчанию для отсутствующих ( нулевых ) значений.
Давайте теперь посмотрим, как мы можем проверить числовые значения с помощью этих методов.
NumberUtils.isParsable ()
Этот метод принимает String и проверяет, является ли это число, которое можно анализировать, или нет, мы можем использовать этот метод вместо перехвата исключения при вызове одного из методов, которые мы упоминали ранее.
Это очень хорошо, потому что по возможности следует избегать решений, связанных с частой обработкой исключений — именно в этом нам помогает этот метод.
Обратите внимание, что шестнадцатеричные числа и научные обозначения не считаются анализируемыми.
Теперь нам даже не нужен вспомогательный вспомогательный метод, поскольку isParseable() возвращает само boolean
String string = "10"; if (NumberUtils.isParsable(string)) < System.out.println("String is numeric!"); >else
Этот код должен вернуть:
String is numeric!
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
String is numeric!
Проверьте, является ли строка числовой с помощью Regex
Несмотря на то, что большинство разработчиков будут довольны использованием уже реализованного метода, иногда у вас может быть очень специфическая проверка шаблона:
public static boolean isNumeric(String string) < // Checks if the provided string // is a numeric by applying a regular // expression on it. String regex = "[0-9]+[\\.]?[0-9]*"; 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