Matcher find java как работает
Регулярные выражения представляют мощный инструмент для обработки строк. Регулярные выражения позволяют задать шаблон, которому должна соответствовать строка или подстрока.
Некоторые методы класса 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() . В итоге программа выдаст следующий результат:
Java JavaScript JavaSE
Замена в строке
Теперь сделаем замену всех совпадений с помощью метода 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
Далее мы подробнее рассмотрим синтаксис регулярных выражений и из каких элементов мы можем создавать шаблоны.
Java RegEx: использование регулярных выражений на практике
Рассмотрим регулярные выражения в Java с учётом особенностей языка и с практическим применением для решения нескольких задач.
Рассмотрим регулярные выражения в Java, затронув синтаксис и наиболее популярные конструкции, а также продемонстрируем работу RegEx на примерах.
- Основы регулярных выражений
- Регулярные выражения в Java
- Примеры использования регулярных выражений в Java
Основы регулярных выражений
Мы подробно разобрали базис в статье Регулярные выражения для новичков, поэтому здесь пробежимся по основам лишь вскользь.
Определение
Регулярные выражения представляют собой формальный язык поиска и редактирования подстрок в тексте. Допустим, нужно проверить на валидность e-mail адрес. Это проверка на наличие имени адреса, символа @ , домена, точки после него и доменной зоны.
Вот самая простая регулярка для такой проверки:
^[A-Z0-9+_.-]+@[A-Z0-9.-]+$ В коде регулярные выражения обычно обозначается как regex, regexp или RE.
Синтаксис RegEx
Символы могут быть буквами, цифрами и метасимволами, которые задают шаблон:
Есть и другие конструкции, с помощью которых можно сокращать регулярки:
- \d — соответствует любой одной цифре и заменяет собой выражение [0-9];
- \D — исключает все цифры и заменяет [^0-9];
- \w — заменяет любую цифру, букву, а также знак нижнего подчёркивания;
- \W — любой символ кроме латиницы, цифр или нижнего подчёркивания;
- \s — поиск символов пробела;
- \S — поиск любого непробельного символа.
Квантификаторы
Это специальные ограничители, с помощью которых определяется частота появления элемента — символа, группы символов, etc:
- ? — делает символ необязательным, означает 0 или 1 . То же самое, что и .
- * — 0 или более, .
- + — 1 или более, .
- — означает число в фигурных скобках.
- — не менее n и не более m раз.
- *? — символ ? после квантификатора делает его ленивым, чтобы найти наименьшее количество совпадений.
Примеры использования квантификаторов в регулярных выражениях
Обратите внимание, что квантификатор применяется только к символу, который стоит перед ним.
Также квантификаторов есть три режима:
"А.+а" //жадный режим — поиск самого длинного совпадения "А.++а" //сверхжадный режим — как жадный, но без реверсивного поиска при захвате строки "А.+?а" //ленивый режим — поиск самого короткого совпадения По умолчанию квантификатор всегда работает в жадном режиме. Подробнее о квантификаторах в Java вы можете почитать здесь.
Примеры их использования рассмотрим чуть дальше.
Регулярные выражения в Java
Поскольку мы говорим о регекспах в Java, то следует учитывать спецификации данного языка программирования.
Экранирование символов в регулярных выражениях Java
В коде Java нередко можно встретить обратную косую черту \ : этот символ означает, что следующий за ним символ является специальным, и что его нужно особым образом интерпретировать. Так, \n означает перенос строки. Посмотрим на примере:
String s = "Это спецсимвол Java. \nОн означает перенос строки."; System.out.println(s); Это спецсимвол Java. Он означает перенос строки. Поэтому в регулярных выражениях для, например, метасимволов, используется двойная косая черта, чтобы указать компилятору Java, что это элемент регулярки. Пример записи поиска символов пробела:
String regex = "\\s"; Ключевые классы
Java RegExp обеспечиваются пакетом java.util.regex. Здесь ключевыми являются три класса:
- Matcher — выполняет операцию сопоставления в результате интерпретации шаблона.
- Pattern — предоставляет скомпилированное представление регулярного выражения.
- PatternSyntaxException — предоставляет непроверенное исключение, что указывает на синтаксическую ошибку, допущенную в шаблоне RegEx.
Также есть интерфейс MatchResult, который представляет результат операции сопоставления.
Примеры использования регулярных выражений в Java
e-mail адрес
В качестве первого примера мы упомянули регулярку, которая проверяет e-mail адрес на валидность. И вот как эта проверка выглядит в Java-коде:
List emails = new ArrayList(); emails.add("name@gmail.com"); //Неправильный имейл: emails.add("@gmail.com"); String regex = "^[A-Za-z0-9+_.-]+@(.+)$"; Pattern pattern = Pattern.compile(regex); for(String email : emails)
name@gmail.com : true @gmail.com : false Телефонный номер
Регулярное выражение для валидации номера телефона:
^((8|\+7)[\- ]?)?(\(?\d\)?[\- ]?)?[\d\- ]$ Эта регулярка ориентирована на российские мобильные номера, а также на городские с кодом из трёх цифр. Попробуйте написать код самостоятельно по принципу проверки e-mail адреса.
IP адрес
А вот класс для определения валидности IP адреса, записанного в десятичном виде:
private static boolean checkIP(String input) < return input.matches("((0|1\\d|2([0-4][0-9]|5[0-5]))\\.)(0|1\\d|2([0-4][0-9]|5[0-5]))"); > Правильное количество открытых и закрытых скобок в строке
На каждую открытую должна приходиться одна закрытая скобка:
private static boolean checkExpression(String input) < Pattern pattern = Pattern.compile("\\([\\d+/*-]*\\)"); Matcher matcher = pattern.matcher(input); do < input = matcher.replaceAll(""); matcher = pattern.matcher(input); >while (matcher.find()); return input.matches("[\\d+/*-]*"); > Извлечение даты
Теперь давайте извлечём дату из строки:
private static String[] getDate(String desc) < int count = 0; String[] allMatches = new String[2]; Matcher m = Pattern.compile("(0[1-9]|[12][0-9]|3[01])[- /.](0[1-9]|1[012])[- /.](19|20)\\d\\d").matcher(desc); while (m.find()) < allMatches[count] = m.group(); count++; >return allMatches; > public static void main(String[] args) throws Exception< String[] dates = getDate("coming from the 25/11/2020 to the 30/11/2020"); System.out.println(dates[0]); System.out.println(dates[1]); > 25/11/2020 30/11/2020 А вот использование различных режимов квантификаторов, принцип работы которых мы рассмотрели чуть ранее.
Жадный режим
Pattern pattern = Pattern.compile("a+"); Matcher matcher = pattern .matcher("aaa"); while (matcher.find())
Найдено от 0 дo 2 В заданном шаблоне первый символ – a . Matcher сопоставляет его с каждым символом текста, начиная с нулевой позиции и захватывая всю строку до конца, в чём и проявляется его «жадность». Вот и получается, что заданная стартовая позиция – это 0, а последняя – 2.
Сверхжадный режим
Pattern pattern = Pattern.compile("a++"); Matcher matcher = pattern .matcher("aaa"); while (matcher.find())
Найдено от 0 дo 2 Принцип, как и в жадном режиме, только поиск заданного символа в обратном направлении не происходит. В приведённой строке всё аналогично: заданная стартовая позиция – это 0, а последняя – 2.
Ленивый режим
Pattern pattern = Pattern.compile("a+?"); Matcher matcher = pattern .matcher("aaa"); while (matcher.find())
Найдено от 0 дo 0 Найдено от 1 дo 1 Найдено от 2 дo 2 Здесь всё просто: самое короткое совпадение находится на первой, второй и третьей позиции заданной строки.
Выводы
Общий принцип использования регулярных выражений сохраняется от языка к языку, однако если мы всё-таки говорим о RegEx в конкретном языке программирования, следует учитывать его спецификации. В Java это экранирование символов, использование специальной библиотеки java.util.regex и её классов.
А какие примеры использования регулярных выражений в Java хотели бы видеть вы? Напишите в комментариях.
Разница между Java Matcher find() и match()
При работе с регулярными выражениями в Java мы обычно хотим искать последовательность символов для данного Pattern . Чтобы облегчить это, API регулярных выражений Java предоставляет класс Matcher , который мы можем использовать для сопоставления заданного регулярного выражения с текстом.
Как правило, мы почти всегда хотим использовать один из двух популярных методов класса Matcher :
В этом кратком руководстве мы узнаем о различиях между этими методами на простом наборе примеров.
2. Метод find ()
Проще говоря, метод find() пытается найти вхождение шаблона регулярного выражения в заданную строку . Если в строке найдено несколько вхождений, то первый вызов find() перейдет к первому вхождению. После этого каждый последующий вызов метода find() будет переходить к следующему совпадению, один за другим.
Давайте представим, что мы хотим найти в предоставленной строке «до свидания 2019 и добро пожаловать 2020» только четырехзначные числа.
Для этого мы будем использовать шаблон «\\d\\d\\d\\d» :
@Test public void whenFindFourDigitWorks_thenCorrect() Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020"); assertTrue(m.find()); assertEquals(8, m.start()); assertEquals("2019", m.group()); assertEquals(12, m.end()); assertTrue(m.find()); assertEquals(25, m.start()); assertEquals("2020", m.group()); assertEquals(29, m.end()); assertFalse(m.find()); > Поскольку в этом примере у нас есть два вхождения — 2019 и 2020 , — метод find() дважды вернет true , а как только он достигнет конца области совпадения, он вернет false .
Как только мы найдем какое-либо совпадение, мы можем использовать такие методы, как start() , group() и end() , чтобы получить более подробную информацию о совпадении , как показано выше.
Метод start() даст начальный индекс совпадения, end() вернет последний индекс символа после окончания совпадения, а group() вернет фактическое значение совпадения .
3. Метод find (int)
Также у нас есть перегруженная версия метода find — find(int) . Он принимает начальный индекс в качестве параметра и рассматривает начальный индекс как отправную точку для поиска вхождений в строке .
Давайте посмотрим, как использовать этот метод на том же примере, что и раньше:
@Test public void givenStartIndex_whenFindFourDigitWorks_thenCorrect() Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020"); assertTrue(m.find(20)); assertEquals(25, m.start()); assertEquals("2020", m.group()); assertEquals(29, m.end()); > Поскольку мы предоставили начальный индекс 20 , мы видим, что теперь найдено только одно вхождение — 2020, которое, как и ожидалось, происходит после этого индекса . И, как и в случае с find() , мы можем использовать такие методы, как start() , group() и end() , чтобы извлечь больше деталей о совпадении.
4. Метод match ()
С другой стороны, методmatches () пытается сопоставить всю строку с шаблоном .
Для того же примера match() вернет false :
@Test public void whenMatchFourDigitWorks_thenFail() Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020"); assertFalse(m.matches()); > Это связано с тем, что он попытается сопоставить «\\d\\d\\d\\d» со всей строкой « прощай, 2019 и добро пожаловать, 2020» — в отличие от методов find() и find(int) , оба из которых найти вхождение шаблона в любом месте строки .
Если мы изменим строку на четырехзначное число «2019» , тогда match() вернет true :
@Test public void whenMatchFourDigitWorks_thenCorrect() Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("2019"); assertTrue(m.matches()); assertEquals(0, m.start()); assertEquals("2019", m.group()); assertEquals(4, m.end()); assertTrue(m.matches()); > Как показано выше, мы также можем использовать такие методы, как start() , group() и end() , чтобы собрать больше деталей о совпадении. Следует отметить один интересный момент: многократный вызов find() может возвращать разные выходные данные после вызова этих методов, как мы видели в нашем первом примере, но match() всегда будет возвращать одно и то же значение.
5. Разница между matcher() и Pattern.matches()
Как мы видели в предыдущем разделе, метод matcher() возвращает Matcher , который сопоставляет заданный ввод с шаблоном.
С другой стороны, Pattern.matches() — это статический метод, который компилирует регулярное выражение и сопоставляет с ним весь ввод .
Давайте создадим тестовые примеры, чтобы подчеркнуть разницу:
@Test public void whenUsingMatcher_thenReturnTrue() Pattern pattern = Pattern.compile(REGEX); Matcher matcher = pattern.matcher(STRING_INPUT); assertTrue(matcher.find()); > Короче говоря, когда мы используем matcher() , мы задаем вопрос: содержит ли строка шаблон?
А с помощью Pattern.matches() мы спрашиваем: является ли строка шаблоном?
Давайте посмотрим на это в действии:
@Test public void whenUsingMatches_thenReturnFalse() assertFalse(Pattern.matches(REGEX, STRING_INPUT)); > Так как Pattern.matches() пытается сопоставить всю строку, она возвращает false .
6. Заключение
В этой статье мы увидели, как find() , find(int) иmatch () отличаются друг от друга на практическом примере. Мы также видели, как различные методы, такие как start() , group() и end() , могут помочь нам извлечь больше деталей о заданном совпадении .
Как всегда, полный исходный код статьи доступен на GitHub .
- 1. Обзор
- 2. Метод find ()
- 3. Метод find (int)
- 4. Метод match ()
- 5. Разница между matcher() и Pattern.matches()
- 6. Заключение
Java Matcher find is false but matches is true [закрыт]
Вопрос вызван проблемой, которая больше не воспроизводится, или опечаткой. Хотя похожие вопросы могут быть уместны на этом сайте, решение для этого вопроса вряд ли поможет будущим посетителям. Обычно можно избежать подобных вопросов написанием и исследованием минимальной программы для воспроизведения проблемы до публикации вопроса.
Закрыт 1 год назад .
Я попытался разобрать строку с помощью регулярного выражения, но столкнулся с каким-то странным поведением
System.out.println(m.matches()); //returns true System.out.println(m.find()); //returns false Похоже, у меня есть несколько ошибок в моем регулярном выражении. Весь код приведен ниже
import java.util.regex.Matcher; import java.util.regex.Pattern; public class testRegexp < public static void main(String[] args) < String string = "Alexandr TheMakedonian 32"; Pattern pattern = Pattern.compile("(.*)\\s(.*)\\s(.*)"); Matcher m = pattern.matcher(string); System.out.println(m.matches()); System.out.println(m.find()); System.out.println(m.groupCount()); if( m.find() && m.groupCount() >= 3) < String firstName = m.group(1); String secondName = m.group(2); String ages = m.group(3); System.out.println(firstName); System.out.println(secondName); System.out.println(ages); >> > Отслеживать
Serg Sergy
задан 20 июн 2022 в 15:29
Serg Sergy Serg Sergy
9 3 3 бронзовых знака
Please translate your question to the Russian language, because this segment of SO is for the Russian-speaking people
20 июн 2022 в 15:31
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
Вызов String.matches() сравнивает целую строку с шаблоном и после этого позиция для нового поиска перемещается в конец и соответственно последующий вызов find вернёт false , так как будет сравниваться пустая строка с шаблоном, в котором есть как минимум два пробела.
Если к примеру переставить вызовы данных методов местами или «сбросить» поиск при помощи Matcher::reset , оба вызова вернут true :
System.out.println(m.find()); // true System.out.println(m.matches()); // true Matcher m1 = pattern.matcher(string); System.out.println(m1.matches()); // true m1.reset(); System.out.println(m1.find()); // true