Spec-Zone.ru › OpenJDK 17

Класс 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} Символ с именем Юникода '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))), например, есть четыре такие группы:

  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.

Имена символов 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.

предопределенные и POSIX классы символов в режиме Unicode
Классы Совпадение
\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{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.

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

Since:
1.4
See Also:
  • String.split(String, int)
  • String.split(String)
  • Сериализованная форма

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

Модификатор и тип Поле Описание
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)
Компилирует заданное регулярное выражение и пытается сопоставить заданный ввод с ним.
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
Включает буквальное разбор шаблона.

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

Флаги 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 классов символов.

При указании этого флага предопределённые классы символов и 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
См. также:
  • Matcher.find()

asMatchPredicate

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

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

splitAsStream

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

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

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

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

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

© 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

Spec-Zone.ru

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