Spec-Zone.ru › OpenJDK 24

Класс 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
\\ Обратный слеш
\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} Символ с именем Unicode 'name'
\t Символ табуляции ('\u0009')
\n Символ новой строки (перевод строки) ('\u000A')
\r Символ возврата каретки ('\u000D')
\f Символ разрыва страницы ('\u000C')
\a Символ тревоги (звонок) ('\u0007')
\e Символ escape ('\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], если UNICODE_CHARACTER_CLASS не установлен. См. Поддержка Unicode.
\D Нецифра: [^0-9]
\h Горизонтальный пробельный символ: [ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000]
\H Негоризонтальный пробельный символ: [^\h]
\s Пробельный символ: [ \t\n\x0B\f\r], если UNICODE_CHARACTER_CLASS не установлен. См. Поддержка Unicode.
\S Непробельный символ: [^\s]
\v Вертикальный пробельный символ: [\n\x0B\f\r\x85\u2028\u2029]
\V Невертикальный пробельный символ: [^\v]
\w Символ слова: [a-zA-Z_0-9], если UNICODE_CHARACTER_CLASS не установлен. См. Поддержка Unicode.
\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)
END_OF_DOCUMENT_MARKER
\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 Граница слова: в начале или конце строки, если там есть символ слова (\w); или между символом слова (\w) и не-символом слова (\W), в любом порядке.
\b{g} Граница расширенного кластера графем Юникода
\B Граница не-слова: [^\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
(?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\\)".

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

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

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

Precedence of character class operators.
Приоритет Название Пример
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 включен, то ^ соответствует началу входных данных и после любого окончания строки, кроме конца входных данных. При включенном режиме MULTILINE $ соответствует символу, непосредственно предшествующему окончанию строки или концу последовательности входных данных.

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

Номер группы

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

  1. ((A)(B(C)))
  2. (A)
  3. (B(C))
  4. (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.

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

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

Скрипты, блоки, категории и бинарные свойства Юникода записываются с помощью конструкций \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.

Поддерживаемые категории — это категории Стандарта Юникода в версии, указанной классом Character. Имена категорий — это те, которые определены в Стандарте, как нормативные, так и справочные.

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

  • Буквальный
  • Идеографический
  • Буква
  • Строчные
  • Прописные
  • Заглавные
  • Знаки препинания
  • Управляющие
  • Пробел
  • Цифра
  • Шестнадцатеричная цифра
  • Управление объединением
  • Символ_не_символ
  • Назначенный
  • Эмодзи
  • Представление_эмодзи
  • Модификатор_эмодзи
  • Базовый_модификатор_эмодзи
  • Компонент_эмодзи
  • Расширенная_пиктографика

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

предопределенные и posix классы символов в режиме Юникода
Классы Соответствия
\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 ismethodname (за исключением устаревших), доступны через тот же синтаксис \p{prop}, где указанное свойство имеет имя javamethodname.

Сравнение с 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.

  • Режим свободного пробела в Perl (называемый режимом комментариев в этом классе), обозначаемый (?x) в регулярном выражении (или флагом String.split(String) при компиляции выражения), не игнорирует пробелы внутри классов символов. В этом классе пробелы внутри классов символов должны экранироваться, чтобы считаться частью регулярного выражения в режиме комментариев.

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

Since:
1.4
External Specifications
  • Регулярные выражения Юникода
See Also:
  • String.split(String, int)
  • String.split(String)
  • Serialized Form

Краткое описание полей

Модификатор и тип Поле Описание
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(String regex)
Компилирует заданное регулярное выражение в шаблон.
static Pattern compile(String regex, int flags)
Компилирует заданное регулярное выражение в шаблон с заданными флагами.
int flags()
Возвращает флаги сопоставления этого шаблона.
Matcher matcher(CharSequence input)
Создаёт согласующий объект, который будет сопоставлять заданный ввод с этим шаблоном.
static boolean matches(String regex, CharSequence input)
Компилирует заданное регулярное выражение и пытается сопоставить заданный ввод с ним.
Map<String,Integer> namedGroups()
Возвращает неизменяемую карту, отображающую имена захватывающих групп на номера групп.
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[] splitWithDelimiters(CharSequence input, int limit)
Разделяет заданную последовательность ввода вокруг совпадений с этим шаблоном и возвращает как строки, так и разделители, соответствующие совпадениям.
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 — мнемоника для режима "single-line", как это называется в 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 классов символов.

При указании этого флага (только US-ASCII) предопределённые классы символов и POSIX классы символов соответствуют Техническому стандарту Unicode #18: Регулярные выражения Unicode Приложению C: Свойства совместимости.

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

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

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

С:
1.7
Внешние спецификации
  • Регулярные выражения Unicode
См. также:
  • Значения константных полей

Подробное описание методов

compile

public static Pattern compile(String regex)
Компилирует данное регулярное выражение в шаблон.
Параметры:
regex - Выражение для компиляции
Возвращает:
данное регулярное выражение, скомпилированное в шаблон
Исключения:
PatternSyntaxException - Если синтаксис выражения некорректен

compile

public static Pattern compile(String regex, int flags)
Компилирует данное регулярное выражение в шаблон с указанными флагами.

Установка CANON_EQ среди флагов может нести умеренный риск исчерпания памяти.

Примечание реализации:
Если CANON_EQ указан и количество знаков комбинирования для любого символа слишком велико, выбрасывается OutOfMemoryError.
Параметры:
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
END_OF_DOCUMENT_MARKER

matcher

public Matcher matcher(CharSequence input)
Создаёт матчер, который будет сопоставлять заданный ввод с этим шаблоном.
Замечание по реализации:
При десериализации Pattern, компиляция откладывается до прямого или косвенного вызова этого метода. Таким образом, если у десериализованного шаблона есть CANON_EQ среди его флагов, и количество объединительных знаков для любого символа слишком велико, будет брошено исключение OutOfMemoryError, как и в compile(String, int).
Параметры:
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, limit и результат
Regex Limit Результат
: 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 - Пороговое значение результата, как описано выше
Возвращает:
Массив строк, вычисленных путём разделения входных данных по совпадениям с этим шаблоном

splitWithDelimiters

public String[] splitWithDelimiters(CharSequence input, int limit)
Разделяет заданную последовательность ввода по совпадениям с этим шаблоном и возвращает как строки, так и разделяющие маркеры.

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

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

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

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

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

Пример разделения, показывающий regex, limit и результат
Regex Limit Результат
:+ 2 { "boo", ":::", "and::foo" }
5 { "boo", ":::", "and", "::", "foo" }
-1 { "boo", ":::", "and", "::", "foo" }
o 5 { "b", "o", "", "o", ":::and::f", "o", "", "o", "" }
-1 { "b", "o", "", "o", ":::and::f", "o", "", "o", "" }
0 { "b", "o", "", "o", ":::and::f", "o", "", "o" }
Параметры:
input - Последовательность символов, подлежащая разделению
limit - Пороговое значение результата, как описано выше
Возвращает:
Массив строк, вычисленных путём разделения входных данных по совпадениям с этим шаблоном, чередуя подстроки и разделяющие маркеры
С:
21

split

public String[] split(CharSequence input)
Разделяет заданную последовательность ввода по совпадениям с этим шаблоном.

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

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

Примеры разделения, показывающие regex и результат
Regex Результат
: { "boo", "and", "foo" }
o { "b", "", ":and:f" }
Параметры:
input - Последовательность символов, подлежащая разделению
Возвращает:
Массив строк, вычисленных путём разделения входных данных по совпадениям с этим шаблоном

quote

public static String quote(String s)
Возвращает буквенный шаблон String для указанной String.

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

Метасимволы или последовательности escape во входной последовательности не будут иметь никакого специального значения.
Параметры:
s - Строка, подлежащая литерализации
Возвращает:
Литеральное строковое замещение
С:
1.5

namedGroups

public Map<String,Integer> namedGroups()
Возвращает неизменяемую карту из имён групп захвата к номерам групп. Если нет имён групп, возвращает пустую карту.
Возвращает:
неизменяемая карта из имён групп захвата к номерам групп
С:
20

asPredicate

public Predicate<String> asPredicate()
Создаёт предикат, проверяющий, найдена ли эта паттерн в заданной строке ввода.
API Note:
Этот метод создаёт предикат, который ведет себя так, как будто он создаёт матчер из входной последовательности и затем вызывает find, например, предикат вида:

   s -> matcher(s).find();
 
Возвращает:
Предикат, который можно использовать для поиска совпадения в подпоследовательности строки
Since:
1.8
См. также:
  • Matcher.find()

asMatchPredicate

public Predicate<String> asMatchPredicate()
Создаёт предикат, проверяющий, соответствует ли эта паттерн заданной строке ввода.
API Note:
Этот метод создаёт предикат, который ведет себя так, как будто он создаёт матчер из входной последовательности и затем вызывает matches, например, предикат вида:

   s -> matcher(s).matches();
 
Возвращает:
Предикат, который можно использовать для сопоставления входной строки с этим шаблоном.
Since:
11
См. также:
  • Matcher.matches()

splitAsStream

public Stream<String> splitAsStream(CharSequence input)
Создаёт поток из заданной последовательности ввода вокруг совпадений с этим шаблоном.

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

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

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

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

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

© 1993, 2025, 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://download.java.net/java/early_access/jdk24/docs/api/java.base/java/util/regex/Pattern.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API