java.lang.Object

java.util.regex.Pattern

所有已实现的接口:: Serializable

public final class Pattern extends Object implements Serializable

正则表达式的编译表示。

正则表达式首先必须作为字符串指定，然后编译为此类的实例。然后可以使用生成的模式来创建一个Matcher对象，该对象可以将任意字符序列与正则表达式进行匹配。执行匹配所涉及的所有状态都驻留在匹配器中，因此许多匹配器可以共享相同的模式。

因此，典型的调用顺序如下

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

此类定义了一个matches方法，用于当正则表达式仅使用一次时的便利。此方法在单次调用中编译表达式并将输入序列与其进行匹配。该语句

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

等同于上述三个语句，尽管对于重复匹配来说效率较低，因为它不允许重复使用编译后的模式。

此类的实例是不可变的，并且可以安全地供多个并发线程使用。Matcher类的实例不适合这样的使用。

正则表达式构造的摘要

正则表达式构造，及其匹配内容
构造	匹配内容
字符
x	字符 x
`\\`	反斜杠字符
`\0`n	具有八进制值 `0`n 的字符 (0 `<=` n `<=` 7)
`\0`nn	具有八进制值 `0`nn 的字符 (0 `<=` n `<=` 7)
`\0`mnn	具有八进制值 `0`mnn 的字符 (0 `<=` m `<=` 3, 0 `<=` n `<=` 7)
`\x`hh	具有十六进制值 `0x`hh 的字符
`\u`hhhh	具有十六进制值 `0x`hhhh 的字符
`\x`{h...h}	具有十六进制值 `0x`h...h 的字符 (`Character.MIN_CODE_POINT` <= `0x`h...h <= `Character.MAX_CODE_POINT`)
`\N{`name`}`	具有Unicode字符名称 'name' 的字符
`\t`	制表符字符 (`'\u0009'`)
`\n`	换行（换行）字符 (`'\u000A'`)
`\r`	回车字符 (`'\u000D'`)
`\f`	换页字符 (`'\u000C'`)
`\a`	警报（响铃）字符 (`'\u0007'`)
`\e`	转义字符 (`'\u001B'`)
`\c`x	对应于控制字符 x
字符类
`[abc]`	`a`、`b` 或 `c`（简单类）
`[^abc]`	除了 `a`、`b` 或 `c` 之外的任何字符（否定）
`[a-zA-Z]`	`a` 到 `z` 或 `A` 到 `Z`，包括（范围）
`[a-d[m-p]]`	`a` 到 `d`，或 `m` 到 `p`： `[a-dm-p]`（并集）
`[a-z&&[def]]`	`d`、`e` 或 `f`（交集）
`[a-z&&[^bc]]`	`a` 到 `z`，除了 `b` 和 `c`： `[ad-z]`（减法）
`[a-z&&[^m-p]]`	`a` 到 `z`，而不是 `m` 到 `p`： `[a-lq-z]`（减法）
预定义字符类
`.`	任何字符（可能与行终止符匹配或不匹配）
`\d`	一个数字：如果未设置 * UNICODE_CHARACTER_CLASS，则为 `[0-9]`。请参见Unicode支持。
`\D`	一个非数字： `[^0-9]`
`\h`	一个水平空白字符： `[ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000]`
`\H`	一个非水平空白字符： `[^\h]`
`\s`	一个空白字符：如果未设置 UNICODE_CHARACTER_CLASS，则为 `[ \t\n\x0B\f\r]`。请参见Unicode支持。
`\S`	一个非空白字符： `[^\s]`
`\v`	一个垂直空白字符： `[\n\x0B\f\r\x85\u2028\u2029]`
`\V`	一个非垂直空白字符： `[^\v]`
`\w`	一个单词字符：如果未设置 UNICODE_CHARACTER_CLASS，则为 `[a-zA-Z_0-9]`。请参见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.Character类（简单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`	单词边界：`(?:(?<=\w)(?=\W)\|(?<=\W)(?=\w))`（非单词字符与单词字符相邻的位置）
`\b{g}`	Unicode扩展字形群边界
`\B`	非单词边界：`[^\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模式，则 ^在输入开头和任何行终止符后匹配。在 MULTILINE模式下， $仅在行终止符之前或输入序列的结尾匹配。

组和捕获

组编号

((A)(B(C)))中，有四个这样的组：

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

组名

命名捕获组，然后稍后可以通过“名称”进行反向引用。组名由以下字符组成。第一个字符必须是一个 字母。

大写字母'A'到'Z'（'\u0041'到'\u005a'），
小写字母'a'到'z'（'\u0061'到'\u007a'），
数字'0'到'9'（'\u0030'到'\u0039'），

命名捕获组仍然按照组编号中描述的方式编号。

"aba"与表达式 (a(b)?)+匹配，会将组二设置为 "b"。每次匹配开始时，所有捕获的输入都将被丢弃。

(?开头的组要么是纯粹的、 非捕获组，不捕获文本，也不计入组总数，要么是 命名捕获组。

Unicode支持

Unicode技术标准＃18：Unicode正则表达式的第1级，以及RL2.1规范等效和RL2.2扩展字形簇。

\u2014之类的 Unicode转义序列的处理方式如《Java语言规范》第 3.3节所述。这样的转义序列也直接由正则表达式解析器实现，以便可以在从文件或键盘读取的表达式中使用Unicode转义。因此，字符串 "\u2014"和 "\\u2014"，虽然不相等，但编译成相同的模式，匹配十六进制值为 0x2014的字符。

十六进制表示法（十六进制代码点值）来表示，如 \x{...}中所述，例如，补充字符U+2011F可以指定为 \x{2011F}，而不是代理对的两个连续Unicode转义序列 \uD840 \uDD1F。

Unicode字符名称由命名字符构造\N{...}支持，例如，\N{WHITE SMILING FACE}指定字符\u263A。此类支持的字符名称是由Character.codePointOf(name)匹配的有效Unicode字符名称。

Unicode扩展字形簇由字形簇匹配器\X和相应的边界匹配器\b{g}支持。

\p和 \P构造编写。 \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。

Unicode标准中 Character类指定的版本中的类别。类别名称是标准中定义的，包括规范性和信息性。

二进制属性使用前缀Is指定，如IsAlphabetic。Pattern支持的二进制属性为

字母
表意
字母
小写
大写
标题大小写
标点符号
控制字符
空白字符
数字
十六进制数字
连接控制
非字符代码点
已分配
表情符号
表情符号展示
表情符号修饰符
表情符号修饰符基础
表情符号组件
扩展象形文字

以下的 预定义字符类 和 POSIX字符类 符合 Annex C: 兼容性属性 推荐的规范，当指定了 Unicode技术标准#18: Unicode正则表达式 的 UNICODE_CHARACTER_CLASS 标志时。

Unicode模式下的预定义和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布尔型is方法名方法（除了已弃用的方法）可通过相同的 \p{属性} 语法访问，其中指定的属性名称为 java方法名。

与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)（或在编译表达式时的 COMMENTS 标志）表示，不会忽略字符类内的空格。在此类中，当处于注释模式时，字符类内的空格必须转义才能被视为正则表达式的一部分。

有关正则表达式构造行为的更精确描述，请参阅 精通正则表达式，第3版，Jeffrey E. F. Friedl, O'Reilly and Associates, 2006.

自1.4版本起:

1.4

外部规范

参见:

Field Summary

Fields

Modifier and Type

Field

Description

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行模式。
Method Summary

Modifier and Type

Method

Description

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[]

split(CharSequence input)

围绕此模式的匹配将给定的输入序列拆分。

String[]

split(CharSequence input, int limit)

围绕此模式的匹配将给定的输入序列拆分。

Stream<String>

splitAsStream(CharSequence input)

从给定的输入序列周围创建一个流，匹配此模式。

String[]

splitWithDelimiters(CharSequence input, int limit)

围绕此模式的匹配将给定的输入序列拆分，并返回字符串和匹配的分隔符。

String

toString()

返回此模式的字符串表示形式。

Methods declared in class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Details
- UNIX_LINES
  
  public static final int UNIX_LINES
  
  启用Unix行模式。
  在此模式下，只有'\n'行终止符会在.、^和$的行为中被识别。
  
  Unix行模式也可以通过嵌入式标志表达式(?d)启用。
  参见:
  
  常量字段值
- CASE_INSENSITIVE
  
  public static final int CASE_INSENSITIVE
  
  启用不区分大小写匹配。
  默认情况下，不区分大小写匹配假定只匹配US-ASCII字符集中的字符。通过在此标志与(?i)的表达式一起指定，可以启用Unicode感知不区分大小写匹配。
  
  不区分大小写匹配也可以通过嵌入式标志表达式(?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版本起:
  
  1.5
  
  参见:
  
  常量字段值
- DOTALL
  
  public static final int DOTALL
  
  启用dotall模式。
  在dotall模式下，表达式.匹配任何字符，包括行终止符。默认情况下，此表达式不匹配行终止符。
  
  dotall模式也可以通过嵌入式标志表达式(?s)启用。（s是“单行”模式的助记符，在Perl中称为此模式。）
  参见:
  
  常量字段值
- UNICODE_CASE
  
  public static final int UNICODE_CASE
  
  启用Unicode感知大小写折叠。
  当指定此标志时，启用不区分大小写匹配（通过CASE_INSENSITIVE标志启用）将按照Unicode标准一致的方式进行。默认情况下，不区分大小写匹配假定只匹配US-ASCII字符集中的字符。
  
  Unicode感知大小写折叠也可以通过嵌入式标志表达式(?u)启用。
  
  指定此标志可能会带来性能损耗。
  参见:
  
  常量字段值
- CANON_EQ
  
  public static final int CANON_EQ
  
  启用规范等价性。
  当指定此标志时，仅当两个字符的完整规范分解匹配时，它们才被视为匹配。例如，当指定此标志时，表达式"a\u030A"将与字符串"\u00E5"匹配。默认情况下，匹配不考虑规范等价性。
  
  没有嵌入式标志字符用于启用规范等价性。
  
  指定此标志可能会带来性能损耗和中等风险的内存耗尽。
  参见:
  
  常量字段值
- UNICODE_CHARACTER_CLASS
  
  public static final int UNICODE_CHARACTER_CLASS
  
  启用预定义字符类和POSIX字符类的Unicode版本。
  当指定此标志时，（仅限US-ASCII）预定义字符类和POSIX字符类符合Unicode技术标准＃18：Unicode正则表达式 附录C：兼容性属性。
  
  UNICODE_CHARACTER_CLASS模式也可以通过嵌入式标志表达式(?U)启用。
  
  该标志意味着UNICODE_CASE，即启用Unicode感知大小写折叠。
  
  指定此标志可能会带来性能损耗。
  自1.7版本起:
  
  1.7
  
  外部规范
  
  Unicode正则表达式
  
  参见:
  
  常量字段值

Method Details

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
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"，使用以下参数将产生以下结果：

显示正则表达式、限制和结果的拆分示例
正则表达式	限制	结果
:	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"，使用以下参数将产生以下结果：

显示正则表达式、限制和结果的拆分示例
正则表达式	限制	结果
:+	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"，使用以下表达式产生以下结果：

显示正则表达式和结果的拆分示例
正则表达式	结果
:	`{ "boo", "and", "foo" }`
o	`{ "b", "", ":and:f" }`

参数:: input - 要拆分的字符序列
返回:: 通过在此模式的匹配周围拆分输入计算的字符串数组

quote

public static String quote(String s)

为指定的String返回一个字面模式String。
此方法生成一个String，可用于创建一个Pattern，该模式将匹配字符串s，就好像它是一个字面模式。
输入序列中的元字符或转义序列将不被赋予特殊含义。

参数:

s - 要转换为字面值的字符串

返回:

一个字面字符串替换

自:

1.5
namedGroups

public Map<String,Integer> namedGroups()

返回一个从捕获组名称到组编号的不可修改的映射。如果没有命名组，则返回一个空映射。

返回:

从捕获组名称到组编号的不可修改的映射

自:

20
asPredicate

public Predicate<String> asPredicate()

创建一个谓词，用于测试给定输入字符串中是否存在此模式。
API 注释:
此方法创建一个谓词，其行为就好像它从输入序列创建一个匹配器，然后调用find，例如以下形式的谓词：
```
   s -> matcher(s).find();
 
```
返回:

可用于在字符串子序列上查找匹配项的谓词

自:

1.8

参见:
- Matcher.find()
asMatchPredicate

public Predicate<String> asMatchPredicate()

创建一个谓词，用于测试此模式是否与给定输入字符串匹配。
API 注释:
此方法创建一个谓词，其行为就好像它从输入序列创建一个匹配器，然后调用matches，例如以下形式的谓词：
```
   s -> matcher(s).matches();
 
```
返回:

可用于将输入字符串与此模式匹配的谓词

自:

11

参见:
- Matcher.matches()
splitAsStream

public Stream<String> splitAsStream(CharSequence input)

从给定的输入序列周围匹配此模式创建一个流。
此方法返回的流包含由另一个与此模式匹配的子序列终止或由输入序列的末尾终止的每个输入序列的子字符串。流中的子字符串按照它们在输入中出现的顺序排列。尾随的空字符串将被丢弃，并且不会在流中遇到。

如果此模式不匹配输入的任何子序列，则结果流只有一个元素，即字符串形式的输入序列。

当在输入序列的开头有正宽度匹配时，将在流的开头包含一个空的前导子字符串。然而，在开头的零宽度匹配永远不会产生这样的空前导子字符串。

如果输入序列是可变的，在终端流操作执行期间必须保持不变。否则，终端流操作的结果是未定义的。
参数:

input - 要拆分的字符序列

返回:

通过在此模式的匹配周围拆分输入计算的字符串流

自:

1.8

参见:
- split(CharSequence)

Class Pattern

正则表达式构造的摘要

反斜杠、转义和引用

字符类

行终止符

组和捕获

组编号

组名

Unicode支持

与Perl 5的比较

Field Summary

Method Summary

Methods declared in class java.lang.Object

Field Details

UNIX_LINES

CASE_INSENSITIVE

COMMENTS

MULTILINE

LITERAL

DOTALL

UNICODE_CASE

CANON_EQ

UNICODE_CHARACTER_CLASS

Method Details

compile

compile

pattern

toString

matcher

flags

matches

split

splitWithDelimiters

split

quote

namedGroups

asPredicate

asMatchPredicate

splitAsStream