Перейти к содержимому

Как найти слово по подстроке java regex

  • автор:

Как найти слово по подстроке java regex

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

Некоторые методы класса 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

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

Регулярное выражение для поиска подстроки из символов в строке

Есть регулярное выражение ^(\d<4,7>)$ Оно валидно для поиска строки вида 123456, на данную строку оно реагирует положительно. Но как модифицировать данную регулярку, чтобы найти подобную подстроку 123456 в строке вида:

Вася сегодня съел 123456 яблок 

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

Отслеживать
21.3k 3 3 золотых знака 25 25 серебряных знаков 49 49 бронзовых знаков
задан 8 ноя 2017 в 13:42
3,362 20 20 серебряных знаков 35 35 бронзовых знаков

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Используйте границу слова

String regex = "\\b\\d\\b"; 

Или блоки предварительного просмотра вперёд/назад:

String regex = "(?(?!\\d)"; 

Если шаблон \b стоит перед \d , то перед цифрой не должно быть буквы, цифры или знака подчёркивания. Если шаблон \b стоит после \d , то после цифры не должно быть буквы, цифры или знака подчёркивания.

String s = "Вася сегодня съел 123456 яблок"; String regex = "\\b\\d\\b"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(s); while (matcher.find()) < System.out.println(matcher.group(0)); >// => 123456 

Java RegEx: использование регулярных выражений на практике

Аватарка пользователя Марина Александровна

Рассмотрим регулярные выражения в Java с учётом особенностей языка и с практическим применением для решения нескольких задач.

Рассмотрим регулярные выражения в Java, затронув синтаксис и наиболее популярные конструкции, а также продемонстрируем работу RegEx на примерах.

  1. Основы регулярных выражений
  2. Регулярные выражения в Java
  3. Примеры использования регулярных выражений в Java

Основы регулярных выражений

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

Определение

Регулярные выражения представляют собой формальный язык поиска и редактирования подстрок в тексте. Допустим, нужно проверить на валидность e-mail адрес. Это проверка на наличие имени адреса, символа @ , домена, точки после него и доменной зоны.

Вот самая простая регулярка для такой проверки:

^[A-Z0-9+_.-]+@[A-Z0-9.-]+$ 

В коде регулярные выражения обычно обозначается как regex, regexp или RE.

Синтаксис RegEx

Символы могут быть буквами, цифрами и метасимволами, которые задают шаблон:

Java RegEx: использование регулярных выражений на практике 1

Есть и другие конструкции, с помощью которых можно сокращать регулярки:

  • \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. Здесь ключевыми являются три класса:

  1. Matcher — выполняет операцию сопоставления в результате интерпретации шаблона.
  2. Pattern — предоставляет скомпилированное представление регулярного выражения.
  3. 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 и её классов.

Python RegEx: практическое применение регулярок

А какие примеры использования регулярных выражений в Java хотели бы видеть вы? Напишите в комментариях.

Шпаргалка по регулярным выражениям. В примерах

Регулярные выражения (regex или regexp) очень эффективны для извлечения информации из текста. Для этого нужно произвести поиск одного или нескольких совпадений по определённому шаблону (т. е. определённой последовательности символов ASCII или unicode).

Области применения regex разнообразны, от валидации до парсинга/замены строк, передачи данных в другие форматы и Web Scraping’а.

Одна из любопытных особенностей регулярных выражений в их универсальности, стоит вам выучить синтаксис, и вы сможете применять их в любом (почти) языке программирования (JavaScript, Java, VB, C #, C / C++, Python, Perl, Ruby, Delphi, R, Tcl, и многих других). Небольшие отличия касаются только наиболее продвинутых функций и версий синтаксиса, поддерживаемых движком.

Давайте начнём с нескольких примеров.

Основы

Якоря — ^ и $

^Привет соответствует строке, начинающейся с Привет -> тестпока$ соответствует строке, заканчивающейся на пока^Привет пока$ точное совпадение (начинается и заканчивается как Привет пока)воробушки соответствует любой строке, в которой есть текст воробушки

Квантификаторы — * + ? и <>

abc* соответствует строке, в которой после ab следует 0 или более символов c -> тестabc+ соответствует строке, в которой после ab следует один или более символов cabc? соответствует строке, в которой после ab следует 0 или один символ cabc соответствует строке, в которой после ab следует 2 символа cabc соответствует строке, в которой после ab следует 2 или более символов cabc соответствует строке, в которой после ab следует от 2 до 5 символов ca(bc)* соответствует строке, в которой после ab следует 0 или более последовательностей символов bca(bc) соответствует строке, в которой после ab следует от 2 до 5 последовательностей символов bc

Оператор ИЛИ — | или []

a(b|c) соответствует строке, в которой после a следует b или c -> тестa[bc] как и в предыдущем примере

Символьные классы — \d \w \s и .

\d соответствует одному символу, который является цифрой -> тест\w соответствует слову (может состоять из букв, цифр и подчёркивания) -> тест\s соответствует символу пробела (включая табуляцию и прерывание строки). соответствует любому символу -> тест

Используйте оператор . с осторожностью, так как зачастую класс или отрицаемый класс символов (который мы рассмотрим далее) быстрее и точнее.

У операторов \d , \w и \s также есть отрицания ― \D, \W и \S соответственно.

Например, оператор \D будет искать соответствия противоположенные \d .

Непечатаемые символы также можно искать, например табуляцию \t , новую строку \n , возврат каретки \r .

Флаги

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

Регулярное выражение, как правило, записывается в такой форме / abc /, где шаблон для сопоставления выделен двумя слешами / . В конце выражения, мы определяем значение флага (эти значения можно комбинировать):

  • g (global) ― не возвращает результат после первого совпадения, а продолжает поиск с конца предыдущего совпадения.
  • m (multi line) ― с таким флагом, операторы ^ и $ вызовут совпадение в начале и конце строки ввода (line), вместо строки целиком (string).
  • i (insensitive) ― делает выражение регистронезависимым (например, /aBc/i соответствует AbC).

Средний уровень

Скобочные группы ― ()

a(bc) создаём группу со значением bc -> тестa(?:bc)* оперетор ?: отключает группу -> тестa(?bc) так, мы можем присвоить имя группе -> тест

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

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

Скобочные выражения ― []

[abc] соответствует строке, которая содержит либо символ a или a b или a c -> такой же эффект от a|b|c -> тест[a-c] то же, что и выше[a-fA-F0–9] строка, представляющая одну шестнадцатеричную цифру без учёта регистра -> тест[0–9]% строка, содержащая символ от 0 до 9 перед знаком %[^a-zA-Z] строка, которая не имеет буквы от a до z или от A до Z. В этом случае ^ используется как отрицание в выражении -> тест

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

Жадные и ленивые сопоставления

Квантификаторы ( * + <> ) ― это «жадные» операторы, потому что они продолжают поиск соответствий, как можно глубже ― через весь текст.

Например, выражение <.+>соответствует

simple div

в This is a

simple div

test . Чтобы найти только тэг div ― можно использовать оператор ? , сделав выражение «ленивым»:

Обратите внимание, что хорошей практикой считается не использовать оператор . , в пользу более строгого выражения:

Продвинутый уровень

Границы слов ― \b и \B

\b ― соответствует границе слова, наподобие якоря (он похож на $ и ^ ), где предыдущий символ ― словесный (например, \w ), а следующий ― нет, либо наоборот, (например, это может быть начало строки или пробел).

\B ― соответствует несловообразующей границе. Соответствие не должно обнаруживаться на границе \b .

Обратные ссылки — \1

([abc])\1 \1 соответствует тексту из первой захватываемой группы -> тест([abc])([de])\2\1 можно использовать \2 (\3, \4, и т.д.) для определения порядкового номера захватываемой группы -> тест(? [abc])\k мы присвоили имя foo группе, и теперь ссылаемся на неё используя ― (\k ). Результат, как и в первом выражении -> тест

Опережающие и ретроспективные проверки — (?=) and (?<=)

d(?=r) соответствует d, только если после этого следует r, но r не будет входить в соответствие выражения -> тест(?r)d соответствует d, только если перед этим есть r, но r не будет входить в соответствие выражения -> тест

Вы можете использовать оператор отрицания !

d(?!r) соответствует d, только если после этого нет r, но r не будет входить в соответствие выражения -> тест(?r)d соответствует d, только если перед этим нет r, но r не будет входить в соответствие выражения -> тест

Заключение

Как вы могли убедиться, области применения регулярных выражений разнообразны. Я уверен, что вы сталкивались с похожими задачами в своей работе (хотя бы с одной из них), например такими:

  • Валидация данных (например, правильно ли заполнена строка time)
  • Сбор данных (особенно веб-скрапинг, поиск страниц, содержащих определённый набор слов в определённом порядке)
  • Обработка данных (преобразование сырых данных в нужный формат)
  • Парсинг (например, достать все GET параметры из URL или текст внутри скобок)
  • Замена строк (даже во время написания кода в IDE, можно, например преобразовать Java или C# класс в соответствующий JSON объект, заменить “;” на “,”, изменить размер букв, избегать объявление типа и т.д.)
  • Подсветка синтаксиса, переименование файла, анализ пакетов и многие другие задачи, где нужно работать со строками (где данные не должны быть текстовыми).

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *