Класс Pattern

java.lang.Object
- java.util.regex.Pattern

Все реализуемые интерфейсы:: Serializable

public final class Pattern
extends Object
implements Serializable

Компилированное представление регулярного выражения.

Регулярное выражение, заданное в виде строки, должно быть сначала скомпилировано в экземпляр этого класса. Полученный шаблон затем может быть использован для создания объекта Matcher, который может сопоставлять произвольные последовательности символов с регулярным выражением. Все состояния, участвующие в выполнении сопоставления, хранятся в объекте matcher, поэтому многие объекты matcher могут использовать один и тот же шаблон.

Типичная последовательность вызовов выглядит следующим образом

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

Метод matches определен в этом классе для удобства использования регулярного выражения только один раз. Этот метод компилирует выражение и сопоставляет входную последовательность с ним в одном вызове. Выражение

boolean b = Pattern.matches("a*b", "aaaaab");

эквивалентно трём приведенным выше операциям, но менее эффективно при многократном использовании, поскольку не позволяет повторно использовать скомпилированный шаблон.

Экземпляры этого класса неизменяемы и безопасны для использования в нескольких потоках. Экземпляры класса Matcher не являются безопасными для такого использования.

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

Конструктор	Совпадения
Символы
x	Символ x
`\\`	Символ обратного слэша
`\0`n	Символ с восьмеричным значением `0`n (0 `<=` n `<=` 7)
`\0`nn	Символ с восьмеричным значением `0`nn (0 `<=` n `<=` 7)
`\0`mnn	Символ с восьмеричным значением `0`mnn (0 `<=` m `<=` 3, 0 `<=` n `<=` 7)
`\x`hh	Символ с шестнадцатеричным значением `0x`hh
`\u`hhhh	Символ с шестнадцатеричным значением `0x`hhhh
`\x`{h...h}	Символ с шестнадцатеричным значением `0x`h...h (`Character.MIN_CODE_POINT` ≤ `0x`h...h ≤ `Character.MAX_CODE_POINT`)
`\N{`name`}`	Символ с именем Unicode 'name'
`\t`	Символ табуляции (`'\u0009'`)
`\n`	Символ новой строки (поворот строки) (`'\u000A'`)
`\r`	Символ возврата каретки (`'\u000D'`)
`\f`	Символ подачи формы (`'\u000C'`)
`\a`	Символ оповещения (звонок) (`'\u0007'`)
`\e`	Символ Escape (`'\u001B'`)
`\c`x	Управляющий символ, соответствующий x
Классы символов
`[abc]`	`a`, `b`, или `c` (простой класс)
`[^abc]`	Любой символ, кроме `a`, `b`, или `c` (отрицание)
`[a-zA-Z]`	`a` по `z` или `A` по `Z`, включительно (диапазон)
`[a-d[m-p]]`	`a` по `d`, или `m` по `p`: `[a-dm-p]` (объединение)
`[a-z&&[def]]`	`d`, `e`, или `f` (пересечение)
`[a-z&&[^bc]]`	`a` по `z`, за исключением `b` и `c`: `[ad-z]` (вычитание)
`[a-z&&[^m-p]]`	`a` по `z`, и не `m` по `p`: `[a-lq-z]`(вычитание)
Предопределенные классы символов
`.`	Любой символ (может или не может соответствовать разделителям строк)
`\d`	Цифра: `[0-9]`
`\D`	Не цифра: `[^0-9]`
`\h`	Горизонтальный пробельный символ: `[ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000]`
`\H`	Не горизонтальный пробельный символ: `[^\h]`
`\s`	Пробельный символ: `[ \t\n\x0B\f\r]`
`\S`	Не пробельный символ: `[^\s]`
`\v`	Вертикальный пробельный символ: `[\n\x0B\f\r\x85\u2028\u2029]`
`\V`	Не вертикальный пробельный символ: `[^\v]`
`\w`	Символ слова: `[a-zA-Z_0-9]`
`\W`	Не символ слова: `[^\w]`
Классы символов POSIX (только US-ASCII)
`\p{Lower}`	Маленькая буквенная буква: `[a-z]`
`\p{Upper}`	Заглавная буквенная буква:`[A-Z]`
`\p{ASCII}`	Все ASCII:`[\x00-\x7F]`
`\p{Alpha}`	Буквенный символ:`[\p{Lower}\p{Upper}]`
`\p{Digit}`	Десятичная цифра: `[0-9]`
`\p{Alnum}`	Буквенно-цифровой символ:`[\p{Alpha}\p{Digit}]`
`\p{Punct}`	Пунктуация: Один из !"#$%&'()*+,-./:;<=>?@[\]^_`{\|}~
`\p{Graph}`	Видимый символ: `[\p{Alnum}\p{Punct}]`
`\p{Print}`	Печатный символ: `[\p{Graph}\x20]`
`\p{Blank}`	Пробел или табуляция: `[ \t]`
`\p{Cntrl}`	Управляющий символ: `[\x00-\x1F\x7F]`
`\p{XDigit}`	Шестнадцатеричная цифра: `[0-9a-fA-F]`
`\p{Space}`	Пробельный символ: `[ \t\n\x0B\f\r]`
Классы символов java.lang (простой тип символа java)
`\p{javaLowerCase}`	Эквивалентно java.lang.Character.isLowerCase()
`\p{javaUpperCase}`	Эквивалентно java.lang.Character.isUpperCase()

Классы для сценариев Юникода, блоков, категорий и двоичных свойств
`\p{javaWhitespace}`	Эквивалентно java.lang.Character.isWhitespace()
`\p{javaMirrored}`	Эквивалентно java.lang.Character.isMirrored()
`\p{IsLatin}`	Символ латинского сценария (сценарий)
`\p{InGreek}`	Символ в блоке греческих символов (блок)
`\p{Lu}`	Заглавная буква (категория)
`\p{IsAlphabetic}`	Символ алфавита (двоичное свойство)
`\p{Sc}`	Символ валюты
`\P{InGreek}`	Любой символ, кроме символа в блоке греческих символов (отрицание)
`[\p{L}&&[^\p{Lu}]]`	Любая буква, кроме заглавной буквы (вычитание)
Сопоставители границ
`^`	Начало строки
`$`	Конец строки
`\b`	Граница слова
`\b{g}`	Граница расширенного кластера графем Юникода
`\B`	Граница не слова
`\A`	Начало входных данных
`\G`	Конец предыдущего совпадения
`\Z`	Конец входных данных, но не конечного терминатора, если таковой имеется
`\z`	Конец входных данных
Сопоставитель разрывов строк
`\R`	Любая последовательность разрывов строк Юникода, эквивалентна `\u000D\u000A\|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]`
Сопоставитель расширенных кластеров графем Юникода
`\X`	Любой расширенный кластер графем Юникода
Жадные квантификаторы
X`?`	X, один раз или не используется
X`*`	X, ноль или более раз
X`+`	X, один или более раз
X`{`n`}`	X, ровно n раз
X`{`n`,`}	X, как минимум n раз
X`{`n`,`m`}`	X, как минимум n, но не более m раз
Ленивые квантификаторы
X`??`	X, один раз или не используется
X`*?`	X, ноль или более раз
X`+?`	X, один или более раз
X`{`n`}?`	X, ровно n раз
X`{`n`,}?`	X, как минимум n раз
X`{`n`,`m`}?`	X, как минимум n, но не более m раз
Притяжательные квантификаторы
X`?+`	X, один раз или не используется
X`*+`	X, ноль или более раз
X`++`	X, один или более раз
X`{`n`}+`	X, ровно n раз
X`{`n`,}+`	X, как минимум n раз
X`{`n`,`m`}+`	X, как минимум n, но не более m раз
Логические операторы
XY	X за которым следует Y
X`\|`Y	X или Y
`(`X`)`	X, как группа захвата
Обратные ссылки
`\`n	То, что было сопоставлено с n^ой группой захвата
`\`k<name>	То, что было сопоставлено с именной группой захвата "name"
Кавычки
`\`	Ничего, но указывает на следующий символ
`\Q`	Ничего, но цитирует все символы до `\E`
`\E`	Ничего, но заканчивает цитирование, начатое `\Q`
Специальные конструкции (с именной группой захвата и без)
`(?<name>`X`)`	X, как именная группа захвата
`(?:`X`)`	X, как группа без захвата
`(?idmsuxU-idmsuxU)`	Ничего, но включает/выключает флаги сопоставления i d m s u x U

`(?idmsux-idmsux:`X`)`	X, как незахватывающая группа с заданными флагами i d m s u x включено/выключено
`(?=`X`)`	X, с помощью положительного предпросмотра нулевой ширины
`(?!`X`)`	X, с помощью отрицательного предпросмотра нулевой ширины
`(?<=`X`)`	X, с помощью положительного постпросмотра нулевой ширины
`(?<!`X`)`	X, с помощью отрицательного постпросмотра нулевой ширины
`(?>`X`)`	X, как независимая незахватывающая группа

Обратные слэши, экранирование и цитирование

Символ обратного слэша ('\') служит для ввода экранированных конструкций, как определено в таблице выше, а также для цитирования символов, которые в противном случае интерпретировались бы как неэкранированные конструкции. Таким образом, выражение \\ соответствует одному обратному слэшу, а \{ соответствует левой фигурной скобке.

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

Обратные слэши в строковых литералах в исходном коде Java интерпретируются в соответствии с Спецификацией языка Java™, как либо escape-последовательности Unicode (раздел 3.3), либо другие escape-последовательности символов (раздел 3.10.6). Поэтому необходимо удваивать обратные слэши в строковых литералах, представляющих регулярные выражения, чтобы защитить их от интерпретации компилятором байт-кода Java. Например, строковый литерал "\b", интерпретируемый как регулярное выражение, соответствует одному символу удаления обратного пробела, в то время как "\\b" соответствует границе слова. Строковый литерал "$hello$" является недопустимым и приводит к ошибке времени компиляции; для соответствия строке (hello) необходимо использовать строковый литерал "\$hello\$".

Классы символов

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

Прецеденция операторов класса символов следующая, от высшего к низшему:

Прецеденция	Название	Пример
1	Экранирование литерала	`\x`
2	Группирование	`[...]`
3	Диапазон	`a-z`
4	Объединение	`[a-e][i-u]`
5	Пересечение	`[a-z&&[aeiou]]`

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

Разделители строк

Разделитель строки — это последовательность из одного или двух символов, которая отмечает конец строки в последовательности входных символов. Следующие считаются разделителями строк:

Символ новой строки (перевод строки) ('\n'),
Символ возврата каретки, за которым немедленно следует символ новой строки ("\r\n"),
Самостоятельный символ возврата каретки ('\r'),
Символ следующей строки ('\u0085'),
Символ разделителя строк ('\u2028'), или
Символ разделителя абзацев ('\u2029').

Если включен режим UNIX_LINES, то распознаются только символы новой строки.

Регулярное выражение . соответствует любому символу, кроме разделителя строки, если не указан флаг DOTALL.

По умолчанию регулярные выражения ^ и $ игнорируют разделители строк и соответствуют только началу и концу соответственно всей входной последовательности. Если включен режим MULTILINE, то ^ соответствует началу ввода и после любого разделителя строк, кроме конца ввода. При включенном режиме MULTILINE $ соответствует строке перед разделителем строк или концом входной последовательности.

Группы и захват

Номер группы

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

((A)(B(C)))
(A)
(B(C))
(C)

Группа ноль всегда соответствует всему выражению.

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

Имя группы

Захватывающей группе также может быть присвоено «имя», named-capturing group, а затем позже к ней можно обратиться по «имени». Имена групп состоят из следующих символов. Первый символ должен быть letter.

Заглавные буквы 'A' по 'Z' ('\u0041' по '\u005a'),
Строчные буквы 'a' по 'z' ('\u0061' по '\u007a'),
Цифры '0' по '9' ('\u0030' по '\u0039'),

Группа named-capturing group все еще нумеруется, как описано в Номере группы.

Захваченный ввод, связанный с группой, всегда является подпоследовательностью, которая последней сопоставлялась с группой. Если группа оценивается второй раз из-за квантификации, то ее ранее захваченное значение, если таковое имеется, будет сохранено, если второе вычисление не удастся. Сопоставление строки "aba" с выражением (a(b)?)+, например, устанавливает группу два на "b". Весь захваченный ввод удаляется в начале каждого совпадения.

Группы, начинающиеся с (?, являются либо чистыми, незахватывающими группами, которые не захватывают текст и не учитываются в общее количество групп, или именованными захватывающими группами.

Поддержка Unicode

Этот класс соответствует уровню 1 Техническому стандарту Unicode #18: Регулярные выражения Unicode, а также RL2.1 Каноническим эквивалентам.

Escape-последовательности Unicode, такие как \u2014 в исходном коде Java, обрабатываются так, как описано в разделе 3.3 Спецификации языка Java™. Такие escape-последовательности также реализуются непосредственно парсером регулярных выражений, так что escape-последовательности Unicode могут использоваться в выражениях, которые считываются из файлов или с клавиатуры. Таким образом, строки "\u2014" и "\\u2014", хотя и не равны, компилируются в один и тот же шаблон, который соответствует символу с шестнадцатеричным значением 0x2014.

Символ Unicode также может быть представлен с использованием его шестнадцатеричной нотации (шестнадцатеричное значение кодового точки) напрямую, как описано в конструкции \x{...}, например, дополнительный символ U+2011F может быть указан как \x{2011F}, вместо двух последовательных escape-последовательностей Unicode пар суррогатов \uD840\uDD1F.

Имена символов Unicode поддерживаются именованной конструкцией символов \N{...}, например, \N{WHITE SMILING FACE} указывает символ \u263A. Поддерживаемые этим классом имена символов — это допустимые имена символов Unicode, соответствующие Character.codePointOf(name).

Расширенные кластеры символов Unicode поддерживаются сопоставителем кластеров символов \X и соответствующим сопоставителем границ \b{g}.

Скрипты, блоки, категории и бинарные свойства Unicode записываются с помощью конструкций \p и \P как в Perl. \p{prop} соответствует, если у ввода есть свойство prop, в то время как \P{prop} не соответствует, если у ввода есть это свойство.

Скрипты, блоки, категории и бинарные свойства могут использоваться как внутри, так и вне класса символов.

Скрипты указываются либо с префиксом Is, как в IsHiragana, либо с использованием ключевого слова script (или его короткой формы sc) как в script=Hiragana или sc=Hiragana.

Поддерживаемые Pattern имена скриптов — это допустимые имена скриптов, принятые и определенные в UnicodeScript.forName.

Блоки задаются префиксом In, как в InMongolian, или с помощью ключевого слова block (или его сокращённой формы blk) как в block=Mongolian или blk=Mongolian.

Названия блоков, поддерживаемые Pattern, являются допустимыми именами блоков, принятыми и определёнными UnicodeBlock.forName.

Категории могут быть указаны с необязательным префиксом Is: Как \p{L}, так и \p{IsL} обозначают категорию символов Юникода. Как и для скриптов и блоков, категории также могут быть указаны с помощью ключевого слова general_category (или его сокращённой формы gc) как в general_category=Lu или gc=Lu.

Поддерживаемые категории соответствуют Стандарту Юникода в версии, указанной классом Character. Названия категорий определены в Стандарте, как нормативные, так и информативные.

Бинарные свойства задаются префиксом Is, как в IsAlphabetic. Поддерживаемые бинарные свойства Pattern:

Буквенный
Идеографический
Буква
Строчный
Прописной
Заглавный
Знак препинания
Управляющий
Пробельный
Цифровой
Шестнадцатеричный
Управляющий соединением
Несимвол
Присвоенный

Следующие Предопределённые классы символов и POSIX классы символов соответствуют рекомендациям Приложения C: Свойства совместимости из Регулярных выражений Юникода, когда установлен флаг UNICODE_CHARACTER_CLASS.

Классы	Совпадения
`\p{Lower}`	Строчный символ:`\p{IsLowercase}`
`\p{Upper}`	Прописной символ:`\p{IsUppercase}`
`\p{ASCII}`	Все ASCII:`[\x00-\x7F]`
`\p{Alpha}`	Буквенный символ:`\p{IsAlphabetic}`
`\p{Digit}`	Цифровой символ:`\p{IsDigit}`
`\p{Alnum}`	Символ из букв и цифр:`[\p{IsAlphabetic}\p{IsDigit}]`
`\p{Punct}`	Символ препинания:`\p{IsPunctuation}`
`\p{Graph}`	Видимый символ: `[^\p{IsWhite_Space}\p{gc=Cc}\p{gc=Cs}\p{gc=Cn}]`
`\p{Print}`	Печатаемый символ: `[\p{Graph}\p{Blank}&&[^\p{Cntrl}]]`
`\p{Blank}`	Пробел или табуляция: `[\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]]`
`\p{Cntrl}`	Управляющий символ: `\p{gc=Cc}`
`\p{XDigit}`	Шестнадцатеричная цифра: `[\p{gc=Nd}\p{IsHex_Digit}]`
`\p{Space}`	Пробельный символ:`\p{IsWhite_Space}`
`\d`	Цифра: `\p{IsDigit}`
`\D`	Не цифра: `[^\d]`
`\s`	Пробельный символ: `\p{IsWhite_Space}`
`\S`	Не пробельный символ: `[^\s]`
`\w`	Символ слова: `[\p{Alpha}\p{gc=Mn}\p{gc=Me}\p{gc=Mc}\p{Digit}\p{gc=Pc}\p{IsJoin_Control}]`
`\W`	Не символ слова: `[^\w]`

Категории, которые ведут себя как методы java.lang.Character boolean isимя_метода (за исключением устаревших), доступны с помощью того же синтаксиса \p{свойство}, где указанное свойство имеет имя javamethodname.

Сравнение с Perl 5

Двигатель Pattern выполняет традиционное сопоставление на основе NFA с упорядоченной заменой, как в Perl 5.

Конструкции Perl, не поддерживаемые этим классом:

Конструкции обратной ссылки, \g{n} для n^-го захватывающего блока и \g{имя} для именованного захватывающего блока.
Условные конструкции (?(условие)X) и (?(условие)X|Y),
Конструкции встраиваемого кода (?{код}) и (??{код}),
Синтаксис встраиваемых комментариев (?#comment), и
Предобработка операций \l \u, \L, и \U.

Конструкции, поддерживаемые этим классом, но не Perl:

Объединение и пересечение классов символов, как описано выше.

Заметные отличия от Perl:

В Perl, \1 до \9 всегда интерпретируются как обратные ссылки; число с обратным слешем, большее чем 9, обрабатывается как обратная ссылка, если существует хотя бы столько же подвыражений, в противном случае, если возможно, интерпретируется как восьмеричный код-описание. В этом классе восьмеричные коды-описания всегда должны начинаться с нуля. В этом классе, \1 до \9 всегда интерпретируются как обратные ссылки, и более большое число принимается как обратная ссылка, если по крайней мере столько же подвыражений существует в этой точке в регулярном выражении, в противном случае парсер будет отбрасывать цифры, пока число не станет меньше или равно существующему числу групп, или это будет однозначное число.
Perl использует флаг g для запроса совпадения, которое возобновляется в том месте, где закончилось последнее совпадение. Эта функция предоставляется неявно классом Matcher: Повторные вызовы метода find будут возобновлять выполнение в месте, где закончилось последнее совпадение, если только матчер не будет сброшен.
В Perl, встроенные флаги на верхнем уровне выражения влияют на всё выражение. В этом классе встроенные флаги всегда действуют в точке, где они появляются, независимо от того, находятся они на верхнем уровне или внутри группы; в последнем случае флаги восстанавливаются в конце группы, как и в Perl.

Для более точного описания поведения конструкций регулярных выражений, обратитесь к Mastering Regular Expressions, 3rd Edition, Jeffrey E. F. Friedl, O'Reilly and Associates, 2006.

С момента:: 1.4
См. также:: String.split(String, int), String.split(String), Форматирование сериализации

Поля

Модификатор и тип	Поле	Описание
`static int`	`CANON_EQ`	Включает каноническое соответствие.
`static int`	`CASE_INSENSITIVE`	Включает регистронезависимое соответствие.
`static int`	`COMMENTS`	Разрешает пробелы и комментарии в шаблоне.
`static int`	`DOTALL`	Включает режим dotall.
`static int`	`LITERAL`	Включает буквальное чтение шаблона.
`static int`	`MULTILINE`	Включает режим многострочный.
`static int`	`UNICODE_CASE`	Включает регистронезависимое соответствие Юникода.
`static int`	`UNICODE_CHARACTER_CLASS`	Включает версию Юникода для предопределённых классов символов и POSIX классов символов.
`static int`	`UNIX_LINES`	Включает режим Unix-строк.

Методы

Модификатор и тип	Метод	Описание
`Predicate<String>`	`asMatchPredicate()`	Создаёт предикат, проверяющий, соответствует ли эта модель заданной входной строке.
`Predicate<String>`	`asPredicate()`	Создаёт предикат, проверяющий, найдена ли эта модель в заданной входной строке.
`static Pattern`	`compile(String regex)`	Компилирует заданное регулярное выражение в модель.
`static Pattern`	`compile(String regex, int flags)`	Компилирует заданное регулярное выражение в модель с заданными флагами.
`int`	`flags()`	Возвращает флаги сопоставления этой модели.
`Matcher`	`matcher(CharSequence input)`	Создаёт согласующийся объект, который будет сопоставлять заданный ввод с данной моделью.
`static boolean`	`matches(String regex, CharSequence input)`	Компилирует заданное регулярное выражение и пытается сопоставить заданный ввод с ним.
`String`	`pattern()`	Возвращает регулярное выражение, из которого была скомпилирована данная модель.
`static String`	`quote(String s)`	Возвращает литеральную модель `String` для указанного `String`.
`String[]`	`split(CharSequence input)`	Разделяет заданную последовательность ввода по соответствиям с этой моделью.
`String[]`	`split(CharSequence input, int limit)`	Разделяет заданную последовательность ввода по соответствиям с этой моделью.
`Stream<String>`	`splitAsStream(CharSequence input)`	Создаёт поток из заданной последовательности ввода по соответствиям с этой моделью.
`String`	`toString()`	Возвращает строковое представление этой модели.

Методы, объявленные в классе java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Поля

UNIX_LINES

public static final int UNIX_LINES

Включает режим строк UNIX.

В этом режиме, только '\n' признаётся в поведении ., ^, и $.

Режим строк UNIX также может быть включён через встроенное выражение флага (?d).

См. также:: Значения константных полей

CASE_INSENSITIVE

public static final int CASE_INSENSITIVE

Включает нечувствительность к регистру.

По умолчанию нечувствительность к регистру предполагает, что сопоставляются только символы в наборе символов US-ASCII. Чувствительность к регистру с учётом Unicode может быть включена, указав флаг UNICODE_CASE в сочетании с этим флагом.

Нечувствительность к регистру также может быть включена через встроенное выражение флага (?i).

Указание этого флага может привести к небольшой потере производительности.

См. также:: Значения константных полей

COMMENTS

public static final int COMMENTS

Разрешает пробелы и комментарии в модели.

В этом режиме пробелы игнорируются, а встроенные комментарии, начинающиеся с #, игнорируются до конца строки.

Режим комментариев также можно включить с помощью встроенного выражения флага (?x).

См. также:: Значения константных полей

MULTILINE

public static final int MULTILINE

Включает многострочный режим.

В многострочном режиме выражения ^ и $ соответствуют только после или непосредственно перед, соответственно, разделителем строк или концом последовательности ввода. По умолчанию эти выражения соответствуют только началу и концу всей последовательности ввода.

Многострочный режим также можно включить с помощью встроенного выражения флага (?m).

См. также:: Значения константных полей

LITERAL

public static final int LITERAL

Включает буквальное чтение модели.

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

Флаги CASE_INSENSITIVE и UNICODE_CASE сохраняют своё влияние на сопоставление при использовании совместно с этим флагом. Другие флаги становятся излишними.

Для включения буквального чтения нет встроенного символа флага.

С:: 1.5
См. также:: Значения константных полей

DOTALL

public static final int DOTALL

Включает режим dotall.

В режиме dotall выражение . соответствует любому символу, включая разделители строк. По умолчанию это выражение не соответствует разделителям строк.

Режим dotall также можно включить с помощью встроенного выражения флага (?s). (s - мнемоника для режима "одной строки", как это называется в Perl).

См. также:: Значения константных полей

UNICODE_CASE

public static final int UNICODE_CASE

Включает Unicode-чувствительность к регистру.

Когда этот флаг задан, нечувствительность к регистру, когда она включена флагом CASE_INSENSITIVE, выполняется в соответствии с Unicode-стандартом. По умолчанию нечувствительность к регистру предполагает, что сопоставляются только символы в наборе символов US-ASCII.

Unicode-чувствительность к регистру также может быть включена с помощью встроенного выражения флага (?u).

Указание этого флага может повлиять на производительность.

См. также:: Значения константных полей

CANON_EQ

public static final int CANON_EQ

Включает каноническое равенство.

Когда этот флаг задан, два символа будут считаться совпадающими, если и только если их полные канонические разложения совпадают. Выражение "a\u030A", например, будет соответствовать строке "\u00E5" при указании этого флага. По умолчанию сопоставление не учитывает каноническое равенство.

Встроенного символа флага для включения канонического равенства нет.

Указание этого флага может повлиять на производительность.

См. также:: Значения константных полей

UNICODE_CHARACTER_CLASS

public static final int UNICODE_CHARACTER_CLASS

Включает Unicode-версию предопределённых классов символов и POSIX-классов символов.

Когда этот флаг указан, предопределённые классы символов и POSIX-классы символов (только US-ASCII) соответствуют Unicode Technical Standard #18: Unicode Regular Expression Приложению C: Свойства совместимости.

Режим UNICODE_CHARACTER_CLASS также может быть включён с помощью встроенного выражения флага (?U).

Флаг подразумевает UNICODE_CASE, то есть включает Unicode-чувствительность к регистру.

Указание этого флага может повлиять на производительность.

С:: 1.7
См. также:: Значения константных полей

Методы

compile

public static Pattern compile(String regex)

Компилирует заданное регулярное выражение в шаблон.

Параметры:: regex - Выражение, подлежащее компиляции
Возвращает:: заданное регулярное выражение, скомпилированное в шаблон
Исключения:: PatternSyntaxException - Если синтаксис выражения некорректен

compile

public static Pattern compile(String regex,
                              int flags)

Компилирует заданное регулярное выражение в шаблон с заданными флагами.

Параметры:: regex - Выражение, подлежащее компиляции; flags - Флаги сопоставления, битовая маска, которая может включать CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS и COMMENTS
Возвращает:: заданное регулярное выражение, скомпилированное в шаблон с заданными флагами
Исключения:: IllegalArgumentException - Если битовые значения, отличные от соответствующих определённым флагам сопоставления, установлены в flags; PatternSyntaxException - Если синтаксис выражения некорректен

pattern

public String pattern()

Возвращает регулярное выражение, из которого был скомпилирован этот шаблон.

Возвращает:: Источник этого шаблона

toString

public String toString()

Возвращает строковое представление этого шаблона. Это регулярное выражение, из которого был скомпилирован этот шаблон.

Переопределяет:: toString в классе Object
Возвращает:: Строковое представление этого шаблона
С момента:: 1.5

matcher

public Matcher matcher(CharSequence input)

Создаёт сопоставитель, который будет сопоставлять заданный ввод с этим шаблоном.

Параметры:: input - Последовательность символов, подлежащая сопоставлению
Возвращает:: Новый сопоставитель для этого шаблона

flags

public int flags()

Возвращает флаги сопоставления этого шаблона.

Возвращает:: Флаги сопоставления, указанные при компиляции этого шаблона

matches

public static boolean matches(String regex,
                              CharSequence input)

Компилирует заданное регулярное выражение и пытается сопоставить заданный ввод с ним.

Вызов этого удобного метода в форме

Pattern.matches(regex, input);

ведет себя точно так же, как выражение

Pattern.compile(regex).matcher(input).matches()

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

Параметры:: regex - Выражение, подлежащее компиляции; input - Последовательность символов, подлежащая сопоставлению
Возвращает:: соответствует ли регулярное выражение вводу или нет
Исключения:: PatternSyntaxException - Если синтаксис выражения некорректен

split

public String[] split(CharSequence input,
                      int limit)

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

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

Параметр limit управляет числом применений шаблона и, следовательно, влияет на длину результирующего массива.

Если limit положительный, шаблон применяется не более limit - 1 раз, длина массива не будет больше limit, и последняя запись массива будет содержать все входные данные после последнего совпавшего разделителя.
Если limit равен нулю, шаблон применяется столько раз, сколько возможно, массив может иметь любую длину, и пустые хвостовые строки будут отброшены.
Если limit отрицательный, шаблон применяется столько раз, сколько возможно, и массив может иметь любую длину.

Входные данные "boo:and:foo", например, дают следующие результаты с этими параметрами:

Regex	Предел	Результат
:	2	`{ "boo", "and:foo" }`
	5	`{ "boo", "and", "foo" }`
	-2	`{ "boo", "and", "foo" }`
o	5	`{ "b", "", ":and:f", "", "" }`
	-2	`{ "b", "", ":and:f", "", "" }`
	0	`{ "b", "", ":and:f" }`

Параметры:: input - Последовательность символов, подлежащая разделению; limit - Пороговое значение результата, как описано выше
Возвращает:: Массив строк, вычисленный путём разделения ввода вокруг совпадений с этим шаблоном

split

public String[] split(CharSequence input)

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

Этот метод работает так, как будто он вызывает двухаргументный метод split с заданной последовательностью ввода и аргументом ограничения, равным нулю. Конечные пустые строки поэтому не включаются в результирующий массив.

Входные данные "boo:and:foo", например, дают следующие результаты с этими выражениями:

Regex	Результат
:	`{ "boo", "and", "foo" }`
o	`{ "b", "", ":and:f" }`

Параметры:: input - Последовательность символов, подлежащая разделению
Возвращает:: Массив строк, вычисленный путём разделения ввода вокруг совпадений с этим шаблоном

quote

public static String quote(String s)

Возвращает буквенный шаблон String для указанного String.

Этот метод создает String, который может быть использован для создания Pattern, который соответствовал бы строке s так, как будто это был буквенный шаблон.

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

Параметры:: s - Строка, подлежащая литерализации
Возвращает:: Замена буквенной строки
С момента:: 1.5

asPredicate

public Predicate<String> asPredicate()

Создаёт предикат, который проверяет, найден ли этот шаблон в заданной строке ввода.

Примечание API:

Этот метод создаёт предикат, который ведёт себя так, как будто он создаёт сопоставитель из последовательности ввода, а затем вызывает find, например, предикат в форме:

s -> matcher(s).find();

Возвращает:

Предикат, который может быть использован для поиска совпадения в подпоследовательности строки

С момента:

1.8

См. также:

Matcher.find()

asMatchPredicate

public Predicate<String> asMatchPredicate()

Создаёт предикат, который проверяет, соответствует ли этот шаблон заданной строке ввода.

Примечание API:

Этот метод создаёт предикат, который ведёт себя так, как будто он создаёт сопоставитель из последовательности ввода, а затем вызывает matches, например, предикат в форме:

s -> matcher(s).matches();

Возвращает:

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

С момента:

См. также:

Matcher.matches()

splitAsStream

public Stream<String> splitAsStream(CharSequence input)

Создаёт поток из заданной последовательности ввода вокруг совпадений с этим шаблоном.

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

Если этот шаблон не соответствует никакой подпоследовательности входных данных, то полученный поток содержит только один элемент, а именно строковое представление входной последовательности.

Если последовательность ввода изменяемая, она должна оставаться постоянной во время выполнения конечной операции потока. В противном случае результат конечной операции потока не определён.

Параметры:: input - Последовательность символов, подлежащая разделению
Возвращает:: Поток строк, вычисленный путём разделения ввода вокруг совпадений с этим шаблоном
С момента:: 1.8
См. также:: split(CharSequence)

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/regex/Pattern.html