public final class Pattern extends Object implements Serializable
必须首先将正则表达式（指定为字符串）编译为此类的实例。 然后将所得的图案可以被用来创建一个Matcher对象可以匹配任意character sequences针对正则表达式。 执行匹配的所有状态都驻留在匹配器中，所以许多匹配者可以共享相同的模式。
因此，典型的调用序列
Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); boolean b = m.matches();
这个类定义了一个matches方法，以便在正则表达式只使用一次时方便。 该方法编译一个表达式，并在单个调用中匹配输入序列。 该声明
boolean b = Pattern.matches("a*b", "aaaaab");
相当于上面的三个语句，尽管对于重复匹配，它的效率较低，因为它不允许编译的模式被重用。
这个类的实例是不可变的，可以安全地被多个并发线程使用。 该实例Matcher类不适合这样的使用是安全的。
Character.MIN_CODE_POINT <= 0xh...h <= Character.MAX_CODE_POINT) \t The tab character ('\u0009') \n The newline (line feed) character ('\u000A') \r The carriage-return character ('\u000D') \f The form-feed character ('\u000C') \a The alert (bell) character ('\u0007') \e The escape character ('\u001B') \cx The control character corresponding to x Character classes [abc] a, b, or c (simple class) [^abc] Any character except a, b, or c (negation) [a-zA-Z] a through z or A through Z, inclusive (range) [a-d[m-p]] a through d, or m through p: [a-dm-p] (union) [a-z&&[def]] d, e, or f (intersection) [a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction) [a-z&&[^m-p]] a through z, and not m through p: [a-lq-z](subtraction) Predefined character classes . Any character (may or may not match line terminators) \d A digit: [0-9] \D A non-digit: [^0-9] \h A horizontal whitespace character: [ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000] \H A non-horizontal whitespace character: [^\h] \s A whitespace character: [ \t\n\x0B\f\r] \S A non-whitespace character: [^\s] \v A vertical whitespace character: [\n\x0B\f\r\x85\u2028\u2029] \V A non-vertical whitespace character: [^\v] \w A word character: [a-zA-Z_0-9] \W A non-word character: [^\w] POSIX character classes (US-ASCII only) \p{Lower} A lower-case alphabetic character: [a-z] \p{Upper} An upper-case alphabetic character:[A-Z] \p{ASCII} All ASCII:[\x00-\x7F] \p{Alpha} An alphabetic character:[\p{Lower}\p{Upper}] \p{Digit} A decimal digit: [0-9] \p{Alnum} An alphanumeric character:[\p{Alpha}\p{Digit}] \p{Punct} Punctuation: One of !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} A visible character: [\p{Alnum}\p{Punct}] \p{Print} A printable character: [\p{Graph}\x20] \p{Blank} A space or a tab: [ \t] \p{Cntrl} A control character: [\x00-\x1F\x7F] \p{XDigit} A hexadecimal digit: [0-9a-fA-F] \p{Space} A whitespace character: [ \t\n\x0B\f\r] java.lang.Character classes (simple java character type) \p{javaLowerCase} Equivalent to java.lang.Character.isLowerCase() \p{javaUpperCase} Equivalent to java.lang.Character.isUpperCase() \p{javaWhitespace} Equivalent to java.lang.Character.isWhitespace() \p{javaMirrored} Equivalent to java.lang.Character.isMirrored() Classes for Unicode scripts, blocks, categories and binary properties \p{IsLatin} A Latin script character (script) \p{InGreek} A character in the Greek block (block) \p{Lu} An uppercase letter (category) \p{IsAlphabetic} An alphabetic character (binary property) \p{Sc} A currency symbol \P{InGreek} Any character except one in the Greek block (negation) [\p{L}&&[^\p{Lu}]] Any letter except an uppercase letter (subtraction) Boundary matchers ^ The beginning of a line $ The end of a line \b A word boundary \B A non-word boundary \A The beginning of the input \G The end of the previous match \Z The end of the input but for the final terminator, if any \z The end of the input Linebreak matcher \R Any Unicode linebreak sequence, is equivalent to \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029] Greedy quantifiers X? X, once or not at all X* X, zero or more times X+ X, one or more times X{n} X, exactly n times X{n,} X, at least n times X{n,m} X, at least n but not more than m times Reluctant quantifiers X?? X, once or not at all X*? X, zero or more times X+? X, one or more times X{n}? X, exactly n times X{n,}? X, at least n times X{n,m}? X, at least n but not more than m times Possessive quantifiers X?+ X, once or not at all X*+ X, zero or more times X++ X, one or more times X{n}+ X, exactly n times X{n,}+ X, at least n times X{n,m}+ X, at least n but not more than m times Logical operators XY X followed by Y X|Y Either X or Y (X) X, as a capturing group Back references \n Whatever the nth capturing group matched \k<name> Whatever the named-capturing group "name" matched Quotation \ Nothing, but quotes the following character \Q Nothing, but quotes all characters until \E \E Nothing, but ends quoting started by \Q
Special constructs (named-capturing and non-capturing) (?<name>X) X, as a named-capturing group (?:X) X, as a non-capturing group (?idmsuxU-idmsuxU) Nothing, but turns match flags i d m s u x U on - off (?idmsux-idmsux:X) X, as a non-capturing group with the given flags i d m s u x on - off (?=X) X, via zero-width positive lookahead (?!X) X, via zero-width negative lookahead (?<=X) X, via zero-width positive lookbehind (?<!X) X, via zero-width negative lookbehind (?>X) X, as an independent, non-capturing group
反斜杠字符（ '\' ）用于引入如上表中定义的转义结构，以及引用否则将被解释为未转义结构的字符。 因此，表达式\\匹配单个反斜杠， \{匹配左括号。
在任何不表示转义构造的字母字符之前使用反斜杠是一个错误; 这些保留用于将来的正则表达式语言的扩展。 反斜杠可以在非字母字符之前使用，而不管该角色是否是未转义构造的一部分。
Java源代码中的字符串文字中的反斜杠将按照The Java™ Language Specification的要求被解释为Unicode转义（3.3节）或其他字符转义（第3.10.6节）。因此，有必要在表示正则表达式的字符串文字中加上反斜杠，以保护它们免受由Java字节码编译器解释。 例如，字符串文字"\b"在解释为正则表达式时匹配单个退格字符，而"\\b"与字边界匹配。 字符串字面值"\(hello\)"是非法的，并导致编译时错误; 为了匹配字符串(hello) ，必须使用字符串文字"\\(hello\\)" 。
字符类可能出现在其他字符类中，并且可以由联合运算符（隐式）和交集运算符（ && ）组成。 union运算符表示一个包含至少一个操作数类中的每个字符的类。 交点运算符表示包含两个操作数类中的每个字符的类。
字符类运算符的优先级如下，从最高到最低：
1 Literal escape \x 2 Grouping [...] 3 Range a-z 4 Union [a-e][i-u] 5 Intersection [a-z&&[aeiou]]
请注意，一个不同的元字符集在字符类中比字符类以外有效。 例如，正则表达式.在字符类中失去其特殊含义，而表达式-成为形成元字符的范围。
行终止符是一个或两个字符的序列，用于标记输入字符序列的一行的末尾。 以下内容被识别为线路终端器：
如果UNIX_LINES模式被激活，则唯一识别的行终止符是换行符。
正则表达式.匹配除行终止符之外的任何字符，除非指定了DOTALL标志。
默认情况下，正则表达式^和$忽略行终止符，仅分别在整个输入序列的开头和结尾进行匹配。 如果MULTILINE模式被激活，则^在输入开始和任何行终止符之后匹配，除了输入结束。 当在MULTILINE模式$匹配之前一个行终止符或输入序列的结尾。
捕获组通过从左到右计算其开始括号进行编号。 例如，在表达式((A)(B(C)))中，存在四个这样的组：
1 ((A)(B(C))) 2 (A) 3 (B(C)) 4 (C)
组零总是代表整个表达式。
捕获组被如此命名，因为在匹配期间，保存与这样的组匹配的输入序列的每个子序列。 捕获的子序列可以在表达式中稍后通过后向引用使用，并且一旦匹配操作完成，也可以从匹配器中获取捕获的子序列。
捕获组也可以被分配一个“名称”，一个named-capturing group ，然后被“名称”后面引用。 组名由以下字符组成。 第一个字符必须是letter 。
A named-capturing group仍然按照Group number所述进行编号 。
与组相关联的捕获输入始终是组最近匹配的子序列。 如果由于量化而对一个组进行了第二次评估，那么如果第二次评估失败，那么其以前捕获的值（如果有的话）将被保留。 将字符串"aba"与表达式(a(b)?)+进行匹配 ，例如，将组第2组设置为"b" 。 所有捕获的输入在每次匹配开始时被丢弃。
以(? 开头的组是纯粹的非捕获组，不捕获文本，不计入组总数或命名捕获组。
本课程符合Unicode Technical Standard #18: Unicode Regular Expression的1 级 ，加上RL2.1规范等同。
如在Java源代码\u2014 Unicode转义序列如在The Java™ Language Specification第3.3节描述的进行处理。 这样的转义序列也由正则表达式解析器直接实现，以便可以在从文件或键盘读取的表达式中使用Unicode转义。 因此，字符串"\u2014"和"\\u2014"虽然不相等，但编译成相同的模式，与十六进制值0x2014的字符匹配 。
Unicode字符也可以通过使用其十六进制表示法 （ 十六进制代码点值）直接表示在正则表达式中 ，如构造\x{...} 所述 ，例如补充字符U + 2011F可以指定为\x{2011F} ，而不是两个连续的Unicode转义代理对的序列\uD840 \uDD1F 。
Unicode脚本，块，类别和二进制属性用Perl中的\p和\P结构编写。 \p{ prop }匹配如果输入具有属性prop ，而\P{ prop }不匹配，如果输入具有该属性。
脚本，块，类别和二进制属性可以在字符类的内部和外部使用。
Scripts被指定或者与前缀Is ，如IsHiragana ，或通过使用script关键词（或其短形式sc ），如script=Hiragana或sc=Hiragana 。
所支持的脚本名称Pattern是接受和定义的有效脚本名称UnicodeScript.forName 。
Blocks用前缀In （如InMongolian ，或使用关键字block （或其简称blk ），如block=Mongolian或blk=Mongolian 。
受支持的块名称Pattern是接受和定义的有效块名称UnicodeBlock.forName 。
Categories可以用可选前缀Is ： \p{L}和\p{IsL}表示Unicode字母的类别。 与脚本和块相同，也可以使用关键字general_category （或其简称gc ） gc ，如general_category=Lu或gc=Lu 。
支持的类别是那些The Unicode Standard由指定的版本Character类。 类别名称是标准中定义的，包括规范性和信息性。
Binary properties用前缀Is ，如IsAlphabetic 。 由Pattern支持的二进制Pattern是
以下预定义字符类和POSIX字符类符合附件C：Unicode Regular Expression 的兼容性属性的建议 ，当指定了UNICODE_CHARACTER_CLASS标志时。
[\p{Graph}\p{Blank}&&[^\p{Cntrl}]] \p{Blank} A space or a tab: [\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]] \p{Cntrl} A control character: \p{gc=Cc} \p{XDigit} A hexadecimal digit: [\p{gc=Nd}\p{IsHex_Digit}] \p{Space} A whitespace character:\p{IsWhite_Space} \d A digit: \p{IsDigit} \D A non-digit: [^\d] \s A whitespace character: \p{IsWhite_Space} \S A non-whitespace character: [^\s] \w A word character: [\p{Alpha}\p{gc=Mn}\p{gc=Me}\p{gc=Mc}\p{Digit}\p{gc=Pc}\p{IsJoin_Control}] \W A non-word character: [^\w]
Pattern引擎执行与Perl 5中出现的有序交替的传统的基于NFA的匹配。
此类不支持Perl构造：
预定义字符类（Unicode字符）
\X 匹配Unicode extended grapheme cluster
反向引用构造，\g{ñ} 第 n 个 capturing group和\g{ 名 } named-capturing group 。
已命名的字符结构，通过它的名字Unicode字符\N{ 名 }。
条件构造(?( 条件 ) X )和(?( 条件 ) X | Y ) ，
嵌入代码构造(?{ 代码 })和(??{ 代码 }) ，
嵌入式注释语法(?#comment) ，和
预处理操作\l \u，\L和\U。
Perl支持的构造方法
字符类联合和交集，如above 所述 。
与Perl有显着差异
在Perl中， \1至\9总是被解释为反向引用; 如果至少存在许多子表达式，则大于9的反斜杠转义的数字将被视为返回引用，否则，如果可能，将其解释为八进制转义。 在这个类中，八进制转义必须始终以零开始。 在这个类中， \1通过\9总是被解释为反向引用，并且如果至少在正则表达式的那一点存在许多子表达式，则更大的数字被接受为反向引用，否则解析器将丢弃数字，直到数字更小或等于现有的组数，或者是一位数。
Perl使用g标志来请求在最后一场比赛停留的地方恢复的比赛。 该功能由Matcher类隐含提供： find方法的重复调用将在最后一个匹配关闭时恢复，除非匹配器被重置。
在Perl中，表达式顶层的嵌入式标志会影响整个表达式。 在这个类中，嵌入的标志总是在它们出现的时刻生效，无论它们在顶层还是在一个组中; 在后一种情况下，标志在组的结尾恢复，就像在Perl中一样。
有关正则表达式构造的行为的更准确的描述，请参阅Mastering Regular Expressions, 3nd Edition, Jeffrey E. F. Friedl, O'Reilly and Associates, 2006.
String.split(String, int) ，
String.split(String) ，
Serialized Form
| Modifier and Type | Field and Description |
|---|---|
static int |
CANON_EQ
实现规范等价。
|
static int |
CASE_INSENSITIVE
启用不区分大小写的匹配。
|
static int |
COMMENTS
允许空格和注释格式。
|
static int |
DOTALL
启用点阵模式。
|
static int |
LITERAL
启用模式的文字解析。
|
static int |
MULTILINE
启用多行模式。
|
static int |
UNICODE_CASE
启用Unicode感知案例折叠。
|
static int |
UNICODE_CHARACTER_CLASS
启用Unicode版本的
预定义字符类和
POSIX字符类 。
|
static int |
UNIX_LINES
启用Unix行模式。
|
| Modifier and Type | Method and Description |
|---|---|
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()
返回此模式的字符串表示形式。
|
public static final int UNIX_LINES
在这种模式下，只有'\n'行结束在.，^和$行为的认可。
Unix行模式也可以通过嵌入式标志表达式(?d)启用 。
public static final int CASE_INSENSITIVE
默认情况下，不区分大小写的匹配假定仅匹配US-ASCII字符集中的字符。 可以通过与此标志一起指定UNICODE_CASE标志来启用Unicode感知不区分大小写的匹配。
也可以通过嵌入式标志表达式(?i)启用不区分大小写的匹配。
指定此标志可能会造成轻微的性能损失。
public static final int COMMENTS
在此模式下，将忽略空格，并且以#开头的嵌入式注释将被忽略，直到行尾。
注释模式也可以通过嵌入式标志表达式(?x)启用 。
public static final int MULTILINE
在多行模式下，表达式^和$分别匹配行终止符或输入序列的结尾。 默认情况下，这些表达式仅在整个输入序列的开头和结尾匹配。
也可以通过嵌入式标志表达式(?m)启用多模式模式。
public static final int LITERAL
当指定此标志时，指定模式的输入字符串将被视为文字字符序列。 输入序列中的元字符或转义序列将没有特殊的含义。
CASE_INSENSITIVE和UNICODE_CASE标志在与此标志一起使用时保持对匹配的影响。 其他旗帜变得多余。
没有嵌入的标志字符用于启用文字解析。
public static final int DOTALL
在dotall模式下，表达式.匹配任何字符，包括行终止符。 默认情况下，此表达式与行终止符不匹配。
Dotall模式也可以通过嵌入式标志表达式(?s)启用 。 （ s是“单行”模式的助记符，这在Perl中被称为）。
public static final int UNICODE_CASE
当指定此标志时，不区分大小写的匹配（由CASE_INSENSITIVE标志启用）以与Unicode标准一致的方式完成。 默认情况下，不区分大小写的匹配假定仅匹配US-ASCII字符集中的字符。
Unicode感知案例折叠也可以通过嵌入式标志表达式(?u)启用 。
指定此标志可能会造成性能损失。
public static final int CANON_EQ
当指定这个标志时，两个字符将被认为是匹配的，只有当他们的完整的规范分解符合时才匹配。 表达"a\u030A"，例如，将指定该标志时，该字符串"\u00E5"匹配。 默认情况下，匹配不考虑规范等价。
没有嵌入的标志字符用于启用规范等效。
指定此标志可能会造成性能损失。
public static final int UNICODE_CHARACTER_CLASS
当指定此标志时，（仅US-ASCII） 预定义字符类和POSIX字符类符合Unicode Technical Standard #18: Unicode Regular Expression 附件C：兼容性属性 。
也可以通过嵌入式标志表达式(?U)启用UNICODE_CHARACTER_CLASS模式。
该标志意味着UNICODE_CASE，也就是说，它可以支持Unicode感知案例折叠。
指定此标志可能会造成性能损失。
public static Pattern compile(String regex)
regex - 要编译的表达式
PatternSyntaxException - 如果表达式的语法无效
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 - 如果表达式的语法无效
public String pattern()
public String toString()
返回此模式的字符串表示形式。 这是编译此模式的正则表达式。
public Matcher matcher(CharSequence input)
input - 要匹配的字符序列
public int flags()
public static boolean matches(String regex, CharSequence input)
调用这种方便的方式的形式
表现方式与表达式完全相同Pattern.matches(regex, input);
Pattern.compile(regex).matcher(input).matches()
如果一个模式多次被使用，编译一次并重用它将比每次调用此方法更有效。
regex - 要编译的表达式
input - 要匹配的字符序列
PatternSyntaxException - 如果表达式的语法无效
public String[] split(CharSequence input, int limit)
由此方法返回的数组包含输入序列的每个子字符串，由与此模式匹配的另一个子序列终止，或者由输入序列的末尾终止。 数组中的子字符串按照它们在输入中出现的顺序。 如果该模式与输入的任何子序列不匹配，则生成的数组只有一个元素，即字符串形式的输入序列。
当在输入序列的开始处存在正宽度匹配时，在结果数组的开始处包含一个空的前导子串。 开始时的零宽度匹配不会产生这样的空的前导子串。
limit参数控制应用模式的次数，因此影响生成的数组的长度。 如果极限n大于0，则模式最多应用n -1次，数组的长度不大于n ，数组的最后一个条目将包含超出最后一个匹配分隔符的所有输入。 如果n是非正的，那么模式将被应用到尽可能多的次数，并且数组可以有任何长度。 如果n为0，则模式将被应用尽可能多次，数组可以有任何长度，并且尾随的空字符串将被丢弃。
例如，输入"boo:and:foo"通过以下参数产生以下结果：
Regex Limit Result : 2 { "boo", "and:foo" } : 5 { "boo", "and", "foo" } : -2 { "boo", "and", "foo" } o 5 { "b", "", ":and:f", "", "" } o -2 { "b", "", ":and:f", "", "" } o 0 { "b", "", ":and:f" }
input - 要分割的字符序列
limit - 结果阈值，如上所述
public String[] split(CharSequence input)
该方法的工作原理是通过调用具有给定输入序列和限制参数为零的双参数split方法。 因此，尾随的空字符串不会包含在结果数组中。
输入"boo:and:foo" ，例如，使用以下表达式得到以下结果：
Regex Result : { "boo", "and", "foo" } o { "b", "", ":and:f" }
input - 要分割的字符序列
public static String quote(String s)
String的文字模式String 。
该方法产生一个String ，可用于创建一个Pattern ，它将匹配字符串s ，就像它是一个文字模式。
s - 要被字面化的字符串
public Stream<String> splitAsStream(CharSequence input)
由此方法返回的流包含输入序列的每个子字符串，由与该模式匹配的另一个子序列终止，或者由输入序列的结尾终止。 流中的子串按照它们在输入中出现的顺序。 尾随的空字符串将被丢弃，不会在流中遇到。
如果该模式与输入的任何子序列不匹配，则生成的流只有一个元素，即字符串形式的输入序列。
当在输入序列的开始处存在正宽度匹配时，在流的开始处包含空的前导子串。 开始时的零宽度匹配不会产生这样的空的前导子串。
如果输入序列是可变的，则在执行终端流操作期间它必须保持不变。 否则，终端流操作的结果未定义。
input - 要分割的字符序列
split(CharSequence)