Что такое регулярное выражение 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

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

18. Java – Регулярные выражения

Пакет java.util.regex предоставляется Java с целью сопоставления регулярных выражений с шаблоном. Регулярные выражения Java характеризуются существенным сходством с языком программирования Perl и очень просты в освоении.

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

Пакет java.util.regex исходно состоит из следующих трех классов:

Pattern Class – объект класса Pattern представляет скомпилированное представление регулярного выражения. В классе Pattern публичный конструктор не предусмотрен. Для создания шаблона, вам сперва необходимо вызвать один из представленных публичных статичных методов compile(), который далее произведет возврат объекта класса Pattern. Регулярное выражение в данных методах принимается как первый аргумент.
Matcher Class – объект класса Matcher представляет механизм, который интерпретирует шаблон, а также производит операции сопоставления с вводимой строкой. Аналогично классу Pattern, Matcher не содержит публичных конструкторов. Объект класса Matcher может быть получен путем вызова метода matcher() на объекте класса Pattern.
PatternSyntaxException – объект класса PatternSyntaxException представляет непроверяемое исключение, которое обозначает синтаксическую ошибку в шаблоне регулярного выражения.

Группы сбора

Группы сбора представляют способ обращения с несколькими символами как с одной единицей. Они создаются путем размещения символов, которые предстоит сгруппировать, в серии круглых скобок. К примеру, регулярное выражение (dog) составляет отдельную группу, содержащую буквы «d», «o», и «g».

Группы сбора нумеруются посредством определения числа открывающих круглых скобок слева направо. Так, в выражении ((A)(B(C))) присутствуют четыре подобные группы:

Для определения числа групп, представленных в выражении, вызвать метод groupCount на объекте класса matcher в Java. Метод groupCount извлекает число типа int, отображающее количество групп сбора, представленных в сопоставляемом шаблоне.

Также имеется специальная группа, группа 0, которая во всех случаях представляет выражение в полном виде. Данная группа не включается в сумму, представленную методом groupCount.

Пример

Ниже рассмотрен пример регулярного выражения в Java, иллюстрирующий способ выявления строки цифр в представленных буквенно-цифровых строках.

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches < public static void main( String args[] ) < // Строка для сканирования, чтобы найти шаблон String str = "Крещение Руси произошло в 988 году! Не так ли?"; String pattern = "(.*)(\\d+)(.*)"; // Создание Pattern объекта Pattern r = Pattern.compile(pattern); // Создание matcher объекта Matcher m = r.matcher(str); if (m.find( )) < System.out.println("Найдено значение: " + m.group(0)); System.out.println("Найдено значение: " + m.group(1)); System.out.println("Найдено значение: " + m.group(2)); >else < System.out.println("НЕ СОВПАДАЕТ"); >> >

В итоге будет получен следующий результат:

Найдено значение: Крещение Руси произошло в 988 году! Не так ли? Найдено значение: Крещение Руси произошло в 98 Найдено значение: 8

Синтаксис регулярных выражений – символы

В Java регулярные выражения используют специальные символы. В следующей таблице представлены метасимволы доступные в синтаксисе регулярных выражений.

Подвыражение	Обозначение символов
^	Соответствует началу строки.
$	Соответствует концу строки.
.	Соответствует любому одиночному символу, за исключением новой строки. Использование опции m делает возможным соответствие новой строке.
[. ]	Соответствует любому одиночному символу в квадратных скобках.
[^. ]	Соответствует любому одиночному символу вне квадратных скобок.
\A	Начало целой строки.
\z	Конец целой строки.
\Z	Конец целой строки, за исключением допустимого терминатора конца строки.
re*	Соответствует 0 либо более вхождений предыдущего выражения.
re+	Соответствует 1 либо более вхождений предыдущего выражения.
re?	Соответствует 0 либо 1 вхождению предыдущего выражения.
re	Соответствует заданному n числу вхождений предыдущего выражения.
re	Соответствует n или большему числу вхождений предыдущего выражения.
re	Соответствует n как минимум и m в большинстве вложений предыдущего выражения.
a\| b	Соответствует a или b.
(re)	Группирует регулярные выражения и запоминает сравниваемый текст.
(?: re)	Группирует регулярные выражения, не запоминая сравниваемый текст.
(?> re)	Соответствует независимому шаблону без возврата.
\w	Соответствует словесным символам.
\W	Соответствует символам, не образующим слова.
\s	Соответствует пробелу. Эквивалент [\t\n\r\f].
\S	Соответствует непробельному символу.
\d	Соответствует цифре. Эквивалент [0-9].
\D	Соответствует нечисловому символу.
\A	Соответствует началу строки.
\Z	Соответствует окончанию строки. При наличии новой строки, располагается перед ней.
\z	Соответствует концу строки.
\G	Соответствует точке, где оканчивается предыдущее совпадение.
\n	Обратная ссылка на группу сбора под номером «n».
\b	Соответствует границе слова вне квадратных скобок. Соответствует возврату на одну позицию (0x08) внутри квадратных скобок.
\B	Соответствуют границам символов, не образующих слова.
\n, \t, etc.	Соответствует символам перевода строки, возврата каретки, табуляции, и т.д.
\Q	Управление (цитирование) всех символов до символа \E.
\E	Окончание цитаты, открытой при помощи \Q.

Методы класса Matcher

Далее представлен список полезных методов экземпляра класса.

Методы индексов

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

№.	Метод и описание
1	public int start() Возврат начального индекса к предыдущему совпадению.
2	public int start(int group) Возврат начального индекса к последовательности, захваченной данной группой в течение предыдущей операции установления соответствия.
3	public int end() Возврат позиции смещения следом за последним совпадающим символом.
4	public int end(int group) Возврат позиции смещения следом за последним символом к последовательности, захваченной данной группой в течение предыдущей операции установления соответствия.

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

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

№.	Метод и описание
1	public boolean lookingAt() Предпринимает попытку поиска соответствия вводимой последовательности в начале области с шаблоном.
2	public boolean find() Предпринимает попытку поиска следующей подпоследовательности в вводимой последовательности, соответствующей шаблону.
3	public boolean find(int start) Сброс данного поиска соответствия и попытка поиска новой подпоследовательности в вводимой последовательности, соответствующей шаблону с указанного индекса.
4	public boolean matches() Предпринимает попытку поиска совпадений во всей области с шаблоном.

Методы замены

Методы замены представляют полезные методы для замены текста в вводимой строке.

№.	Метод и описание
1	public Matcher appendReplacement(StringBuffer sb, String replacement) Производит нетерминальное присоединение и замену.
2	public StringBuffer appendTail(StringBuffer sb) Производит терминальное присоединение и замену.
3	public String replaceAll(String replacement) Заменяет каждую подпоследовательность в вводимой последовательности, совпадающей с шаблоном, указанным в замещающей строке.
4	public String replaceFirst(String replacement) Замещает первую подпоследовательность в вводимой последовательности, совпадающей с шаблоном, указанным в замещающей строке.
5	public static String quoteReplacement(String s) Возвращает литеральную замену Строки для указанной Строки. Данный метод производит сроку, которая будет функционировать в качестве литеральной замены s в методе appendReplacement класса Matcher.

Методы start и end

Далее представлен пример, в котором производится подсчет количества раз, когда в строке ввода встречается слово «кот».

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches < private static final String REGEX = "\\bкот\\b"; private static final String INPUT = "кот кот кот котёл кот"; public static void main( String args[] ) < Pattern p = Pattern.compile(REGEX); Matcher m = p.matcher(INPUT); // получение matcher объекта int count = 0; while(m.find()) < count++; System.out.println("Номер вхождения: "+count); System.out.println("Начальная позиция вхождения: "+m.start()); System.out.println("Конечная позиция вхождения: "+m.end()); >> >

В итоге будет получен следующий результат:

Номер вхождения: 1 Начальная позиция вхождения: 0 Конечная позиция вхождения: 3 Номер вхождения: 2 Начальная позиция вхождения: 4 Конечная позиция вхождения: 7 Номер вхождения: 3 Начальная позиция вхождения: 8 Конечная позиция вхождения: 11 Номер вхождения: 4 Начальная позиция вхождения: 18 Конечная позиция вхождения: 21

Как видим, в данном примере используются границы слов с целью удостоверения в том, что буквы «c» «a» «t» не являются частью другого слова. Также отображаются определенные полезные сведения касательно нахождения совпадения в вводимой строке.

Метод start производит возврат начального индекса в последовательности, захваченной в данной группе в ходе предыдущей операции поиска совпадений, а end производит возврат индекса к последнему совпавшему символу, плюс один.

Методы matches и lookingAt

Оба метода matches и lookingAt направлены на попытку поиска соответствия вводимой последовательности с шаблоном. Разница, однако, заключается в том, что для метода matches требуется вся вводимая последовательность, в то время как lookingAt этого не требует.

Оба метода всегда начинаются в начале вводимой строки. Далее представлен пример, рассматривающий их функциональность.

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches < private static final String REGEX = "Pro"; private static final String INPUT = "ProgLang"; private static Pattern pattern; private static Matcher matcher; public static void main( String args[] ) < pattern = Pattern.compile(REGEX); matcher = pattern.matcher(INPUT); System.out.println("Текущее регулярное выражение: " + REGEX); System.out.println("Текущие входные данные: " + INPUT); System.out.println("lookingAt(): " + matcher.lookingAt()); System.out.println("matches(): " + matcher.matches()); >>

В итоге будет получен следующий результат:

Текущее регулярное выражение: Pro Текущие входные данные: ProgLang lookingAt(): true matches(): false

Методы replaceFirst и replaceAll

Методы replaceFirst и replaceAll производят замену текста, который совпадает с заданным регулярным выражением. Исходя из их названия, replaceFirst производит замену первого совпадения, а replaceAll производит замену остальных совпадений.

Далее представлен пример, поясняющий их функциональность.

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches < private static String REGEX = "Собака"; private static String INPUT = "Собака говорит мяу."; private static String REPLACE = "Кот"; public static void main(String[] args) < Pattern p = Pattern.compile(REGEX); // получение matcher объекта Matcher m = p.matcher(INPUT); INPUT = m.replaceAll(REPLACE); System.out.println(INPUT); >>

В итоге будет получен следующий результат:

Кот говорит мяу.

Методы appendReplacement и appendTail

Класс Matcher также предоставляет методы замены текста appendReplacement и appendTail.

Далее представлен пример, поясняющий их функциональность.

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches < private static String REGEX = "а*д"; private static String INPUT = "аадProgLangааадProgLangадProgLangд"; private static String REPLACE = "-"; public static void main(String[] args) < Pattern p = Pattern.compile(REGEX); // получение matcher объекта Matcher m = p.matcher(INPUT); StringBuffer sb = new StringBuffer(); while(m.find()) < m.appendReplacement(sb, REPLACE); >m.appendTail(sb); System.out.println(sb.toString()); > >

В итоге будет получен следующий результат:

-ProgLang-ProgLang-ProgLang-

Методы класса PatternSyntaxException

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

№.	Метод и описание
1	public String getDescription() Представляет описание ошибки.
2	public int getIndex() Представляет индекс ошибки.
3	public String getPattern() Представляет шаблон регулярного выражения, содержащего ошибку.
4	public String getMessage() Производит возврат многострочной строки, содержащей описание синтаксической ошибки и ее индекс, ошибочный образец регулярного выражения, а также визуальную индикацию индекса ошибки в шаблоне.

1. Java – Самоучитель для начинающих
2. Java – Обзор языка
3. Java – Установка и настройка
4. Java – Синтаксис
5. Java – Классы и объекты
6. Java – Конструкторы
7. Java – Типы данных и литералы
8. Java – Типы переменных
9. Java – Модификаторы
10. Java – Операторы
11. Java – Циклы и операторы цикла
11.1. Java – Цикл while
11.2. Java – Цикл for
11.3. Java – Улучшенный цикл for
11.4. Java – Цикл do..while
11.5. Java – Оператор break
11.6. Java – Оператор continue
12. Java – Операторы принятия решений
12.1. Java – Оператор if
12.2. Java – Оператор if..else
12.3. Java – Вложенный оператор if
12.4. Java – Оператор switch..case
12.5. Java – Условный оператор (? 🙂
13. Java – Числа
13.1. Java – Методы byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
13.2. Java – Метод compareTo()
13.3. Java – Метод equals()
13.4. Java – Метод valueOf()
13.5. Java – Метод toString()
13.6. Java – Метод parseInt()
13.7. Java – Метод Math.abs()
13.8. Java – Метод Math.ceil()
13.9. Java – Метод Math.floor()
13.10. Java – Метод Math.rint()
13.11. Java – Метод Math.round()
13.12. Java – Метод Math.min()
13.13. Java – Метод Math.max()
13.14. Java – Метод Math.exp()
13.15. Java – Метод Math.log()
13.16. Java – Метод Math.pow()
13.17. Java – Метод Math.sqrt()
13.18. Java – Метод Math.sin()
13.19. Java – Метод Math.cos()
13.20. Java – Метод Math.tan()
13.21. Java – Метод Math.asin()
13.22. Java – Метод Math.acos()
13.23. Java – Метод Math.atan()
13.24. Java – Метод Math.atan2()
13.25. Java – Метод Math.toDegrees()
13.26. Java – Метод Math.toRadians()
13.27. Java – Метод Math.random()
14. Java – Символы
14.1. Java – Метод Character.isLetter()
14.2. Java – Метод Character.isDigit()
14.3. Java – Метод Character.isWhitespace()
14.4. Java – Метод Character.isUpperCase()
14.5. Java – Метод Character.isLowerCase()
14.6. Java – Метод Character.toUpperCase()
14.7. Java – Метод Character.toLowerCase()
14.8. Java – Метод Character.toString()
15. Java – Строки
15.1. Java – Метод charAt()
15.2. Java – Метод compareTo()
15.3. Java – Метод compareToIgnoreCase()
15.4. Java – Метод concat()
15.5. Java – Метод contentEquals()
15.6. Java – Метод copyValueOf()
15.7. Java – Метод endsWith()
15.8. Java – Метод equals()
15.9. Java – Метод equalsIgnoreCase()
15.10. Java – Метод getBytes()
15.11. Java – Метод getChars()
15.12. Java – Метод hashCode()
15.13. Java – Метод indexOf()
15.14. Java – Метод intern()
15.15. Java – Метод lastIndexOf()
15.16. Java – Метод length()
15.17. Java – Метод matches()
15.18. Java – Метод regionMatches()
15.19. Java – Метод replace()
15.20. Java – Метод replaceAll()
15.21. Java – Метод replaceFirst()
15.22. Java – Метод split()
15.23. Java – Метод startsWith()
15.24. Java – Метод subSequence()
15.25. Java – Метод substring()
15.26. Java – Метод toCharArray()
15.27. Java – Метод toLowerCase()
15.28. Java – Метод toString()
15.29. Java – Метод toUpperCase()
15.30. Java – Метод trim()
15.31. Java – Метод valueOf()
15.32. Java – Классы StringBuilder и StringBuffer
15.32.1. Java – Метод append()
15.32.2. Java – Метод reverse()
15.32.3. Java – Метод delete()
15.32.4. Java – Метод insert()
15.32.5. Java – Метод replace()
16. Java – Массивы
17. Java – Дата и время
18. Java – Регулярные выражения
19. Java – Методы
20. Java – Потоки ввода/вывода, файлы и каталоги
20.1. Java – Класс ByteArrayInputStream
20.2. Java – Класс DataInputStream
20.3. Java – Класс ByteArrayOutputStream
20.4. Java – Класс DataOutputStream
20.5. Java – Класс File
20.6. Java – Класс FileReader
20.7. Java – Класс FileWriter
21. Java – Исключения
21.1. Java – Встроенные исключения
22. Java – Вложенные и внутренние классы
23. Java – Наследование
24. Java – Переопределение
25. Java – Полиморфизм
26. Java – Абстракция
27. Java – Инкапсуляция
28. Java – Интерфейсы
29. Java – Пакеты
30. Java – Структуры данных
30.1. Java – Интерфейс Enumeration
30.2. Java – Класс BitSet
30.3. Java – Класс Vector
30.4. Java – Класс Stack
30.5. Java – Класс Dictionary
30.6. Java – Класс Hashtable
30.7. Java – Класс Properties
31. Java – Коллекции
31.1. Java – Интерфейс Collection
31.2. Java – Интерфейс List
31.3. Java – Интерфейс Set
31.4. Java – Интерфейс SortedSet
31.5. Java – Интерфейс Map
31.6. Java – Интерфейс Map.Entry
31.7. Java – Интерфейс SortedMap
31.8. Java – Класс LinkedList
31.9. Java – Класс ArrayList
31.10. Java – Класс HashSet
31.11. Java – Класс LinkedHashSet
31.12. Java – Класс TreeSet
31.13. Java – Класс HashMap
31.14. Java – Класс TreeMap
31.15. Java – Класс WeakHashMap
31.16. Java – Класс LinkedHashMap
31.17. Java – Класс IdentityHashMap
31.18. Java – Алгоритмы Collection
31.19. Java – Iterator и ListIterator
31.20. Java – Comparator
32. Java – Дженерики
33. Java – Сериализация
34. Java – Сеть
34.1. Java – Обработка URL
35. Java – Отправка Email
36. Java – Многопоточность
36.1. Java – Синхронизация потоков
36.2. Java – Межпоточная связь
36.3. Java – Взаимная блокировка потоков
36.4. Java – Управление потоками
37. Java – Основы работы с апплетами
38. Java – Javadoc

Регулярные выражения

Регулярное выражение — это своего рода шаблон, который может быть применен к тексту. Java предоставляет пакет java.util.regex для сопоставления с регулярными выражениями.

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

Например, есть следующая строка:

Используются файлы file1.doc, file2.txt. А еще было бы неплохо обратить внимание на файл file3.img. Также просмотрите содержимое file4.doc.

Из строки нужно вырезать все имена файлов: file1.doc, file2.txt, file3.img, file4.doc. Для нахождения используется регулярное выражение:

[a-zA-Z]+\\.[a-z]

Регулярное выражение [a-z]+ соответствует всем строчным буквам в тексте. [a-z] означает любой символ от a до z включительно, и + означает «один или более» символов.

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

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexDemo1 < public static void main(String[] args) < String stringPattern = "[a-z]+"; String text = "code 2 learn java tutorial"; Pattern pattern = Pattern.compile(stringPattern); Matcher matcher = pattern.matcher(text); while (matcher.find()) < System.out.println(text.substring(matcher.start(), matcher.end())); >> >

2. Pattern и Matcher классы

Pattern класс — объект класса составляет представление регулярного выражения. Класс Pattern не предусматривает никаких публичных конструкторов. Чтобы создать шаблон, необходимо сначала вызвать один из публичных статических методов, которые затем возвращают объект класса Pattern. Эти методы принимают регулярное выражение в качестве аргумента.

Matcher класс — объект «Искатель» является двигателем, который интерпретирует шаблон и выполняет операции сопоставления с входной строкой. Как и Pattern класс, Matcher не имеет публичных конструкторов. Вы получаете объект Matcher вызовом метода matcher(), на объекте класса Pattern.

Методы класса Matcher:

matches() возвращает true , если шаблон соответствует всей строке, иначе false .
lookingAt() возвращает true , если шаблон соответствует началу строки, и false в противном случае.
find() возвращает true , если шаблон совпадает с любой частью текста.

3. Основные мета символы

^	(крышка) начало проверяемой строки.
$	(доллар) конец проверяемой строки.
.	(точка) представляет собой сокращенную форму записи для символьного класса, совпадающего с любым символом.
\|	Означает «или». Подвыражения, объединенные этим способом, называются альтернативами (alternatives).
?	(знак вопроса) означает, что предшествующий ему символ является необязательным.
+	Обозначает «один или несколько экземпляров непосредственно предшествующего элемента.
*	Любое количество экземпляров элемента (в том числе и нулевое).
\\d	Цифровой символ.
\\D	Не цифровой символ.
\\s	Пробельный символ.
\\S	Не пробельный символ.
\\w	Буквенный(латиница), цифровой символ или знак подчёркивания.
\\W	Любой символ, кроме буквенного, цифрового символа или знака подчёркивания.
[abc]	Диапазон символов или цифр.

Примеры регулярных выражений:

a? - a один раз или ни разу a* - a ноль или более раз a+ - a один или более раз a - a n раз a- a n или более раз a- a от n до m

4. Сравнение регулярного выражения с текстом

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexDemo2 < public static void main(String[] args) < Pattern pattern = Pattern.compile("a*b"); Matcher matcher = pattern.matcher("aaab"); boolean b = matcher.matches(); System.out.println(b); >>

5. Простой валидатор ссылки

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexDemo3 < public static void main(String[] args) < System.out.println(test("google.com")); System.out.println(test("reference1.ua")); System.out.println(test("reference1.org")); >public static boolean test(String testString) < Pattern pattern = Pattern.compile(".+\\.(com|ua|ru)"); Matcher matcher = pattern.matcher(testString); return matcher.matches(); >>

6. Регулярное выражение для проверки email

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexDemo4 < public static void main(String[] args) < String regex = "(\\w)@(\\w+\\.)([a-z])"; String s = "адреса эл.почты:ivanov@gmail.com, sidorov@bsu.by!"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(s); while (matcher.find()) < System.out.println("e-mail: " + matcher.group()); >> >

7. Методы Pattern.split(), String.split()

Класс Pattern содержит метод split() , который разбивает строку на подстроки, используя указанный в шаблоне разделитель:

import java.util.Arrays; import java.util.regex.Pattern; public class RegexDemo5 < public static void main(String[] args) < Pattern pattern = Pattern.compile("\\d+\\s?"); String[] words = pattern.split("java5tiger 77 java6mustang"); System.out.print(Arrays.toString(words)); >>

Класс String определяет такой же метод split() :

import java.util.Arrays; public class RegexDemo6 < public static void main(String[] args) < String str = "java5tiger 77 java6mustang"; String[] words = str.split("\\d+\\s?"); System.out.print(Arrays.toString(words)); >>

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

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

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

Основы регулярных выражений
Регулярные выражения в Java
Примеры использования регулярных выражений в 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. Здесь ключевыми являются три класса:

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 и её классов.

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

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

Что такое регулярное выражение java