Класс 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 |
\\ | Символ обратного слэша |
\0n
| Символ с восьмеричным значением 0n (0 <= n <= 7) |
\0nn
| Символ с восьмеричным значением 0nn (0 <= n <= 7) |
\0mnn
| Символ с восьмеричным значением 0mnn (0 <= m <= 3, 0 <= n <= 7) |
\xhh
| Символ с шестнадцатеричным значением 0xhh
|
\uhhhh
| Символ с шестнадцатеричным значением 0xhhhh
|
\x{h...h}
| Символ с шестнадцатеричным значением 0xh...h (Character.MIN_CODE_POINT <= 0xh...h <= Character.MAX_CODE_POINT) |
\N{name}
| Символ с именем Юникода 'name' |
\t | Символ табуляции ('\u0009') |
\n | Символ новой строки (перевода строки) ('\u000A') |
\r | Символ возврата каретки ('\u000D') |
\f | Символ перевода страницы ('\u000C') |
\a | Символ сигнала (звонка) ('\u0007') |
\e | Символ экранирования ('\u001B') |
\cx
| Управляющий символ, соответствующий 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() |
| Классы для шрифтов, блоков, категорий и бинарных свойств Unicode | |
\p{IsLatin} | Символ латинского шрифта (шрифт) |
\p{InGreek} | Символ из блока греческих символов (блок) |
\p{Lu} | Заглавная буква (категория) |
\p{IsAlphabetic} | Буква (бинарное свойство) |
\p{Sc} | Символ валюты |
\P{InGreek} | Любой символ, кроме символа из блока греческих символов (отрицание) |
[\p{L}&&[^\p{Lu}]] | Любая буква, кроме заглавной (вычитание) |
| Сопоставители границ | |
^ | Начало строки |
$ | Конец строки |
\b | Граница слова |
\b{g} | Граница расширенного кластера Unicode графем |
\B | Граница не слова |
\A | Начало входных данных |
\G | Конец предыдущего совпадения |
\Z | Конец входных данных, но без последнего терминатора, если таковой имеется |
\z | Конец входных данных |
| Сопоставитель перевода строки | |
\R | Любая последовательность перевода строки Unicode, эквивалентна \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]
|
| Сопоставитель расширенного кластера Unicode графем | |
\X | Любой расширенный кластер Unicode графем |
| Жадные квантификаторы | |
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 — включены / выключены |
|---|---|
(?idmsuxU-idmsuxU:X) | X, как незахватывающая группа с заданными флагами i d m s u x U — включены / выключены |
(?=X)
| X, через положительный просмотр вперед нулевой ширины |
(?!X)
| X, через отрицательный просмотр вперед нулевой ширины |
(?<=X)
| X, через положительный просмотр назад нулевой ширины |
(?<!X)
| X, через отрицательный просмотр назад нулевой ширины |
(?>X)
| X, как независимая незахватывающая группа |
Обратные слэши, экранирование и цитирование
Символ обратного слэша ('\') служит для ввода экранированных конструкций, как определено в таблице выше, а также для цитирования символов, которые в противном случае интерпретировались бы как неэкранированные конструкции. Таким образом, выражение \\ соответствует одному обратному слэшу, а \{ соответствует левой фигурной скобке.
Использование обратного слэша перед любой буквенной позицией, которая не обозначает экранированную конструкцию, является ошибкой; эти позиции зарезервированы для будущих расширений языка регулярных выражений. Обратный слэш может использоваться перед небуквенным символом независимо от того, является ли этот символ частью неэкранированной конструкции.
Обратные слэши внутри строковых литералов в исходном коде Java интерпретируются в соответствии с Спецификацией языка Java, как символы Unicode (раздел 3.3) или другие символьные экранирования (раздел 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 Канонические эквиваленты и RL2.2 Расширенные кластеры графем.
Последовательности экранирования Unicode, такие как \u2014 в исходном коде Java, обрабатываются, как описано в разделе 3.3 Спецификации языка Java. Такие последовательности экранирования также реализуются непосредственно парсером регулярных выражений, так что последовательности экранирования Unicode можно использовать в выражениях, которые считываются из файлов или с клавиатуры. Таким образом, строки "\u2014" и "\\u2014", хотя и не равны, компилируются в один и тот же шаблон, который соответствует символу с шестнадцатеричным значением 0x2014.
Символ Unicode также может быть представлен с помощью его шестнадцатеричной записи (шестнадцатеричное значение кода точки) напрямую, как описано в конструкции \x{...}, например, дополнительный символ U+2011F может быть задан как \x{2011F}, вместо двух последовательных последовательностей экранирования 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} обозначают категорию символов Unicode. Так же, как скрипты и блоки, категории также можно задавать, используя ключевое слово general_category (или его сокращённую форму gc) как в general_category=Lu или gc=Lu.
Поддерживаемые категории — это категории из The Unicode Standard в версии, указанной классом Character. Названия категорий — это те, которые определены в стандарте, как нормативные, так и информативные.
Бинарные свойства задаются с префиксом Is, как в IsAlphabetic. Поддерживаемые бинарные свойства Pattern:
- Алфавитный
- Идеографический
- Буква
- Строчная
- Прописная
- Заглавная
- Пунктуация
- Управляющий
- Пробел
- Цифра
- Шестнадцатеричная цифра
- Управляющий объединением
- Несимвольный код точки
- Присвоенный
Следующие предопределенные классы символов и классы символов POSIX соответствуют рекомендациям Приложения C: Свойства совместимости Unicode Technical Standard #18: Unicode Regular Expressions, когда установлен флаг 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]
|
Сравнение с Perl 5
Двигатель Pattern выполняет традиционное сопоставление на основе NFA с упорядоченной заменой, как в Perl 5.
Конструкции Perl, не поддерживаемые этим классом:
Конструкции обратной ссылки,
\g{n}для n-ой группы захвата и\g{name}для группы захвата с именем.Условные конструкции
(?(condition)X)и(?(condition)X|Y),Конструкции встроенного кода
(?{code})и(??{code}),Синтаксис встроенных комментариев
(?#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.
- Since:
- 1.4
- See Also:
Краткое описание полей
| Модификатор и тип | Поле | Описание |
|---|---|---|
static final int |
CANON_EQ |
Включает каноническое равенство. |
static final int |
CASE_INSENSITIVE |
Включает регистронезависимое сопоставление. |
static final int |
COMMENTS |
Разрешает пробелы и комментарии в шаблоне. |
static final int |
DOTALL |
Включает режим dotall. |
static final int |
LITERAL |
Включает буквальное разбор шаблона. |
static final int |
MULTILINE |
Включает многострочный режим. |
static final int |
UNICODE_CASE |
Включает Unicode-сознательный сгиб регистра. |
static final int |
UNICODE_CHARACTER_CLASS |
Включает Unicode-версии предопределенных классов символов и POSIX классов символов. |
static final int |
UNIX_LINES |
Включает режим Unix-строк. |
Краткое описание методов
| Модификатор и тип | Метод | Описание |
|---|---|---|
Predicate<String> |
asMatchPredicate() |
Создаёт предикат, проверяющий, соответствует ли этот шаблон заданной строке ввода. |
Predicate<String> |
asPredicate() |
Создаёт предикат, проверяющий, находится ли этот шаблон в заданной строке ввода. |
static Pattern |
compile |
Компилирует заданное регулярное выражение в шаблон. |
static Pattern |
compile |
Компилирует заданное регулярное выражение в шаблон с заданными флагами. |
int |
flags() |
Возвращает флаги сопоставления этого шаблона. |
Matcher |
matcher |
Создаёт согласователь, который будет сопоставлять заданный ввод с этим шаблоном. |
static boolean |
matches |
Компилирует заданное регулярное выражение и пытается сопоставить заданный ввод с ним. |
String |
pattern() |
Возвращает регулярное выражение, из которого был скомпилирован этот шаблон. |
static String |
quote |
Возвращает буквальный шаблон String для указанного String. |
String[] |
split |
Разделяет заданную последовательность ввода вокруг совпадений с этим шаблоном. |
String[] |
split |
Разделяет заданную последовательность ввода вокруг совпадений с этим шаблоном. |
Stream<String> |
splitAsStream |
Создаёт поток из заданной последовательности ввода вокруг совпадений с этим шаблоном. |
String |
toString() |
Возвращает строковое представление этого шаблона. |
Подробное описание полей
UNIX_LINES
public static final int UNIX_LINES
В этом режиме в поведении ., ^, и $ распознаётся только разделитель строк '\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
При указании этого флага входная строка, определяющая шаблон, обрабатывается как последовательность буквальных символов. Метасимволы или последовательности escape в последовательности входных данных не будут иметь специального значения.
Флаги CASE_INSENSITIVE и UNICODE_CASE сохраняют своё влияние на сопоставление при использовании вместе с этим флагом. Другие флаги становятся избыточными.
Нет символа вложенного флага для включения буквального разбора.
- С:
- 1.5
- См. также:
DOTALL
public static final int DOTALL
В режиме dotall выражение . соответствует любому символу, включая разделитель строк. По умолчанию это выражение не соответствует разделителям строк.
Режим dotall также можно включить с помощью вложенного выражения флагов (?s). (s — это мнемоника для режима "single-line", как он называется в Perl.)
- См. также:
UNICODE_CASE
public static final int UNICODE_CASE
При указании этого флага нечувствительное к регистру сопоставление, когда включено флагом 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
При указании этого флага предопределённые классы символов и POSIX классы символов (только US-ASCII) соответствуют Unicode Technical Standard #18: Unicode Regular Expressions Приложению 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 управляет количеством применений шаблона и, следовательно, влияет на длину результирующего массива.
Если предел положителен, шаблон будет применяться не более предел - 1 раз, длина массива не будет больше предел, а последний элемент массива будет содержать все входные данные после последнего совпадения разделителя.
Если предел равен нулю, шаблон будет применяться как можно чаще, длина массива может быть любой, а хвостовые пустые строки будут отброшены.
Если предел отрицателен, шаблон будет применяться как можно чаще, и длина массива может быть любой.
Входные "boo:and:foo", например, дают следующие результаты с этими параметрами:
| Регулярное выражение | Предел | Результат |
|---|---|---|
| : | 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 с данной последовательностью ввода и значением предела 0. Таким образом, хвостовые пустые строки не включаются в результирующий массив.
Входные "boo:and:foo", например, дают следующие результаты с этими выражениями:
| Регулярное выражение | Результат |
|---|---|
| : | { "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:
- Этот метод создаёт предикат, который ведет себя так, как если бы он создал matcher из входной последовательности и затем вызвал
find, например, предикат вида:s -> matcher(s).find(); - Возвращает:
- Предикат, который может использоваться для поиска совпадения в подпоследовательности строки
- С:
- 1.8
- См. также:
asMatchPredicate
public Predicate<String> asMatchPredicate()
- Примечание API:
- Этот метод создаёт предикат, который ведет себя так, как если бы он создал matcher из входной последовательности и затем вызвал
matches, например, предикат вида:s -> matcher(s).matches(); - Возвращает:
- Предикат, который можно использовать для сопоставления входной строки с этим шаблоном.
- С:
- 11
- См. также:
splitAsStream
public Stream<String> splitAsStream(CharSequence input)
Поток, возвращаемый этим методом, содержит каждую подстроку последовательности ввода, которая завершается другой подпоследовательностью, соответствующей этому шаблону, или завершается концом последовательности ввода. Подстроки в потоке находятся в порядке их появления во входной последовательности. Хвостовые пустые строки будут отброшены и не будут встречены в потоке.
Если этот шаблон не соответствует никакой подпоследовательности ввода, то результирующий поток содержит только один элемент — входную последовательность в виде строки.
Если входная последовательность изменяема, она должна оставаться неизменной во время выполнения заключительной операции потока. В противном случае результат заключительной операции потока не определён.
- Параметры:
-
input- Последовательность символов, подлежащая разделению - Возвращает:
- Поток строк, вычисленный путём разделения ввода по совпадениям с этим шаблоном
- С:
- 1.8
- См. также:
© 1993, 2021, 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/17/docs/api/java.base/java/util/regex/Pattern.html