Using regular expressions to extract a value in Java
I want to extract the text in [some number] using the Java regex classes. I know roughly what regular expression I want to use (though all suggestions are welcome). What I’m really interested in are the Java calls to take the regex string and use it on the source data to produce the value of [some number]. I should add that I’m only interested in a single [some number] (basically, the first instance). The source strings are short and I’m not going to be looking for multiple occurrences of [some number].
13 Answers 13
private static final Pattern p = Pattern.compile("^([a-zA-Z]+)(8+)(.*)"); public static void main(String[] args) < // create matcher for pattern p and given string Matcher m = p.matcher("Testing123Testing"); // if an occurrence if a pattern was found in a given string. if (m.find()) < // . then you can use group() methods. System.out.println(m.group(0)); // whole matched expression System.out.println(m.group(1)); // first expression from round brackets (Testing) System.out.println(m.group(2)); // second one (123) System.out.println(m.group(3)); // third one (Testing) >> Since you’re looking for the first number, you can use such regexp:
and m.group(1) will return you the first number. Note that signed numbers can contain a minus sign:
Agreed. Usually I’d define the pattern as a private static final Pattern PATTERN = Pattern.compile(«. «); But that’s just me.
You may also reuse the Matcher. Call the Matcher’s reset() method between each use. If you are sharing the matcher across multiple concurrent threads you should synchronize the operation.
There is one caveat to this approach, hinted at in @Marquez ‘s answer: the Matcher is a state machine. This also includes that p.matcher(
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Regex1 < public static void main(String[]args) < Pattern p = Pattern.compile("\\d+"); Matcher m = p.matcher("hello1234goodboy789very2345"); while(m.find()) < System.out.println(m.group()); >> > Allain basically has the java code, so you can use that. However, his expression only matches if your numbers are only preceded by a stream of word characters.
should be able to find the first string of digits. You don’t need to specify what’s before it, if you’re sure that it’s going to be the first string of digits. Likewise, there is no use to specify what’s after it, unless you want that. If you just want the number, and are sure that it will be the first string of one or more digits then that’s all you need.
If you expect it to be offset by spaces, it will make it even more distinct to specify
If you need all three parts, this will do:
EDIT The Expressions given by Allain and Jack suggest that you need to specify some subset of non-digits in order to capture digits. If you tell the regex engine you’re looking for \d then it’s going to ignore everything before the digits. If J or A’s expression fits your pattern, then the whole match equals the input string. And there’s no reason to specify it. It probably slows a clean match down, if it isn’t totally ignored.
How to extract a substring using regex
To extract a substring from a string using a regular expression in Java, you can use the following steps:
Pattern pattern = Pattern.compile("regex pattern");String input = "input string"; Matcher matcher = pattern.matcher(input);- Use the find() method of the Matcher class to find the first occurrence of the substring that matches the regular expression:
if (matcher.find()) < // the substring was found >String group = matcher.group();Here’s an example of how you can use these steps to extract a substring that consists of the first four characters of an input string:
Pattern pattern = Pattern.compile("^."); String input = "input string"; Matcher matcher = pattern.matcher(input); if (matcher.find()) < String substring = matcher.group(); >The regular expression «^.» matches any four characters at the beginning of the input string (the ^ character denotes the start of the string). The . part of the pattern matches any four characters (the . character matches any character, and the specifies that the preceding character should be matched four times).
Java get substring by regexp
Регулярные выражения представляют мощный инструмент для обработки строк. Регулярные выражения позволяют задать шаблон, которому должна соответствовать строка или подстрока.
Некоторые методы класса String принимают регулярные выражения и используют их для выполнения операций над строками.
split
Для разделения строки на подстроки применяется метод split() . В качестве параметра он может принимать регулярное выражение, которое представляет критерий разделения строки.
Например, разделим предложение на слова:
String text = «FIFA will never regret it»; String[] words = text.split(«\\s*(\\s|,|!|\\.)\\s*»); for(String word : words)
Для разделения применяется регулярное выражение «\\s*(\\s|,|!|\\.)\\s*». Подвыражние «\\s» по сути представляет пробел. Звездочка указывает, что символ может присутствовать от 0 до бесконечного количества раз. То есть добавляем звездочку и мы получаем неопределенное количество идущих подряд пробелов — «\\s*» (то есть неважно, сколько пробелов между словами). Причем пробелы может вообще не быть. В скобках указывает группа выражений, которая может идти после неопределенного количества пробелов. Группа позволяет нам определить набо значений через вертикальную черту, и подстрока должна соответствовать одному из этих значений. То есть в группе «\\s|,|!|\\.» подстрока может соответствовать пробелу, запятой, восклицательному знаку или точке. Причем поскольку точка представляет специальную последовательность, то, чтобы указать, что мы имеем в виду имеено знак точки, а не специальную последовательность, перед точкой ставим слеши.
Соответствие строки. matches
Еще один метод класса String — matches() принимает регулярное выражение и возвращает true, если строка соответствует этому выражению. Иначе возвращает false.
Например, проверим, соответствует ли строка номеру телефона:
String input = «+12343454556»; boolean result = input.matches(«(\\+*)\\d»); if(result) < System.out.println("It is a phone number"); >else
В данном случае в регулярном выражение сначала определяется группа «(\\+*)». То есть вначале может идти знак плюса, но также он может отсутствовать. Далее смотрим, соответствуют ли последующие 11 символов цифрам. Выражение «\\d» представляет цифровой символ, а число в фигурных скобках — — сколько раз данный тип символов должен повторяться. То есть мы ищем строку, где вначале может идти знак плюс (или он может отсутствовать), а потом идет 11 цифровых символов.
Класс Pattern
Большая часть функциональности по работе с регулярными выражениями в Java сосредоточена в пакете java.util.regex .
Само регулярное выражение представляет шаблон для поиска совпадений в строке. Для задания подобного шаблона и поиска подстрок в строке, которые удовлетворяют данному шаблону, в Java определены классы Pattern и Matcher .
Для простого поиска соответствий в классе Pattern определен статический метод boolean matches(String pattern, CharSequence input) . Данный метод возвращает true, если последовательность символов input полностью соответствует шаблону строки pattern:
import java.util.regex.Pattern; public class StringsApp < public static void main(String[] args) < String input = "Hello"; boolean found = Pattern.matches("Hello", input); if(found) System.out.println("Найдено"); else System.out.println("Не найдено"); >> Но, как правило, для поиска соответствий применяется другой способ — использование класса Matcher.
Класс Matcher
Рассмотрим основные методы класса Matcher:
- boolean matches() : возвращает true, если вся строка совпадает с шаблоном
- boolean find() : возвращает true, если в строке есть подстрока, которая совпадает с шаблоном, и переходит к этой подстроке
- String group() : возвращает подстроку, которая совпала с шаблоном в результате вызова метода find. Если совпадение отсутствует, то метод генерирует исключение IllegalStateException .
- int start() : возвращает индекс текущего совпадения
- int end() : возвращает индекс следующего совпадения после текущего
- String replaceAll(String str) : заменяет все найденные совпадения подстрокой str и возвращает измененную строку с учетом замен
Используем класс Matcher. Для этого вначале надо создать объект Pattern с помощью статического метода compile() , который позволяет установить шаблон:
Pattern pattern = Pattern.compile("Hello"); В качестве шаблона выступает строка «Hello». Метод compile() возвращает объект Pattern, который мы затем можем использовать в программе.
В классе Pattern также определен метод matcher(String input) , который в качестве параметра принимает строку, где надо проводить поиск, и возвращает объект Matcher :
String input = "Hello world! Hello Java!"; Pattern pattern = Pattern.compile("hello"); Matcher matcher = pattern.matcher(input); Затем у объекта Matcher вызывается метод matches() для поиска соответствий шаблону в тексте:
import java.util.regex.Matcher; import java.util.regex.Pattern; public class StringsApp < public static void main(String[] args) < String input = "Hello"; Pattern pattern = Pattern.compile("Hello"); Matcher matcher = pattern.matcher(input); boolean found = matcher.matches(); if(found) System.out.println("Найдено"); else System.out.println("Не найдено"); >> Рассмотрим более функциональный пример с нахождением не полного соответствия, а отдельных совпадений в строке:
import java.util.regex.Matcher; import java.util.regex.Pattern; public class StringsApp < public static void main(String[] args) < String input = "Hello Java! Hello JavaScript! JavaSE 8."; Pattern pattern = Pattern.compile("Java(\\w*)"); Matcher matcher = pattern.matcher(input); while(matcher.find()) System.out.println(matcher.group()); >> Допустим, мы хотим найти в строке все вхождения слова Java. В исходной строке это три слова: «Java», «JavaScript» и «JavaSE». Для этого применим шаблон «Java(\\w*)». Данный шаблон использует синтаксис регулярных выражений. Слово «Java» в начале говорит о том, что все совпадения в строке должны начинаться на Java. Выражение (\\w*) означает, что после «Java» в совпадении может находиться любое количество алфавитно-цифровых символов. Выражение \w означает алфавитно-цифровой символ, а звездочка после выражения указывает на неопределенное их количество — их может быть один, два, три или вообще не быть. И чтобы java не рассматривала \w как эскейп-последовательность, как \n, то выражение экранируется еще одним слешем.
Далее применяется метод find() класса Matcher, который позволяет переходить к следующему совпадению в строке. То есть первый вызов этого метода найдет первое совпадение в строке, второй вызов найдет второе совпадение и т.д. То есть с помощью цикла while(matcher.find()) мы можем пройтись по всем совпадениям. Каждое совпадение мы можем получить с помощью метода matcher.group() . В итоге программа выдаст следующий результат:
Замена в строке
Теперь сделаем замену всех совпадений с помощью метода replaceAll() :
String input = "Hello Java! Hello JavaScript! JavaSE 8."; Pattern pattern = Pattern.compile("Java(\\w*)"); Matcher matcher = pattern.matcher(input); String newStr = matcher.replaceAll("HTML"); System.out.println(newStr); // Hello HTML! Hello HTML! HTML 8. Также надо отметить, что в классе String также имеется метод replaceAll() с подобным действием:
String input = "Hello Java! Hello JavaScript! JavaSE 8."; String myStr =input.replaceAll("Java(\\w*)", "HTML"); System.out.println(myStr); // Hello HTML! Hello HTML! HTML 8. Разделение строки на лексемы
С помощью метода String[] split(CharSequence input) класса Pattern можно разделить строку на массив подстрок по определенному разделителю. Например, мы хотим выделить из строки отдельные слова:
import java.util.regex.Pattern; public class StringsApp < public static void main(String[] args) < String input = "Hello Java! Hello JavaScript! JavaSE 8."; Pattern pattern = Pattern.compile("[ . ]"); String[] words = pattern.split(input); for(String word:words) System.out.println(word); >> И консоль выведет набор слов:
Hello Java Hello JavaScript JavaSE 8
При этом все символы-разделители удаляются. Однако, данный способ разбивки не идеален: у нас остаются некоторые пробелы, которые расцениваются как лексемы, а не как разделители. Для более точной и изощренной разбивки нам следует применять элементы регулярных выражений. Так, заменим шаблон на следующий:
Pattern pattern = Pattern.compile("\\s*(\\s|,|!|\\.)\\s*"); Теперь у нас останутся только слова:
Hello Java Hello JavaScript JavaSE 8
Далее мы подробнее рассмотрим синтаксис регулярных выражений и из каких элементов мы можем создавать шаблоны.