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类的实例是不安全的使用。
| Construct | Matches |
|---|---|
| Characters | |
| x | The character x |
| \\ | The backslash character |
| \0n | The character with octal value 0n (0 <= n <= 7) |
| \0nn | The character with octal value 0nn (0 <= n <= 7) |
| \0mnn | The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7) |
| \xhh | The character with hexadecimal value 0xhh |
| \uhhhh | The character with hexadecimal value 0xhhhh |
| \x{h...h} | The character with hexadecimal value 0xh...h (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。
一个named-capturing group仍如Group number编号。
捕获的输入与一组相关联的总序列，集团最近匹配。如果一个组被评估第二次，因为量化，那么它以前捕获的值，如果有的话，将被保留，如果第二次评估失败。例如匹配字符串"aba"对表达(a(b)?)+，叶组，两个"b"。在每一个匹配的开始，所有捕获的输入被丢弃。
组开始(?要么是纯洁的，非捕获组不捕获文本和不计入组总，或命名捕获组。
这个类是与Unicode Technical Standard #18: Unicode Regular Expression 1水平的一致性，加上rl2.1正则等价物。
Unicode转义序列如java源代码\u2014是在The Java™ Language Specification 3.3节中描述的处理。这样的转义序列也由正则表达式解析器直接实现，可以使用Unicode转义表达，在读取文件或从键盘。因此"\u2014"和"\\u2014"字符串，而不是平等的，编译成相同的图案，用十六进制值0x2014的字符匹配。
一个Unicode字符也可以使用正则表达式来表示进制记数法（十六进制代码值）直接描述构建\x{...}，例如补充字符u +分类可以被指定为\x{2011F}，而连续两Unicode转义序列的代理项对\uD840\uDD1F。
Unicode脚本块，类别和二进制属性是用\p和\P作为Perl。\p{道具}比赛如果输入具有财产道具，而\P{道具}不匹配，如果输入特性。
脚本，块，类别和二进制属性可以在一个字符类的内部和外部使用。
Scripts指定的前缀Is，在IsHiragana，或通过使用script关键词（或其缩写形式sc）在script=Hiragana或sc=Hiragana。
Blocks与In指定前缀，如InMongolian，或者使用关键字block（或其缩写形式blk）在block=Mongolian或blk=Mongolian。
支持Pattern块的名字是有效的块名接受和定义的UnicodeBlock.forName。
Categories可以与可选的前缀Is指定：两\p{L}和\p{IsL}表示Unicode字符的范畴。相同的脚本块，类也可以使用关键字general_category指定（或其缩写形式gc）在general_category=Lu或gc=Lu。
支持的类别是由Character类指定的版本 The Unicode Standard那些。类别名称是标准中定义的，规范性和信息性的。
Binary properties与Is指定前缀，如IsAlphabetic。支持二进制属性Pattern是
以下预定义字符类和POSIX字符类是与附件C推荐的一致性：兼容性属性Unicode Regular Expression ，当UNICODE_CHARACTER_CLASS标志指定。
| Classes | Matches |
|---|---|
| \p{Lower} | A lowercase character:\p{IsLowercase} |
| \p{Upper} | An uppercase character:\p{IsUppercase} |
| \p{ASCII} | All ASCII:[\x00-\x7F] |
| \p{Alpha} | An alphabetic character:\p{IsAlphabetic} |
| \p{Digit} | A decimal digit character:p{IsDigit} |
| \p{Alnum} | An alphanumeric character:[\p{IsAlphabetic}\p{IsDigit}] |
| \p{Punct} | A punctuation character:p{IsPunctuation} |
| \p{Graph} | A visible character: [^\p{IsWhite_Space}\p{gc=Cc}\p{gc=Cs}\p{gc=Cn}] |
| \p{Print} | A printable character: [\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引擎执行传统的基于NFA的有序交替发生在Perl 5匹配。
Perl构建这类不支持：
预定义字符类（Unicode字符）
\X match Unicode extended grapheme cluster
后向引用的结构，为named-capturing group为nTHcapturing group和\g{名称} \g{n}。
指定的字符构成，\N{名称} Unicode字符的名称。
有条件的构建(?(条件)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
使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的不区分大小写匹配可以结合此标志指定UNICODE_CASE标志启用。
不区分大小写匹配也可以通过嵌入国旗表达 (?i)启用。
指定该标志可能会施加轻微的性能损失。
public static final int COMMENTS
在这种模式下，空格被忽略，和嵌入的注释开始#被忽略直到一行的结束。
评论模式也可以通过嵌入国旗表达 (?x)启用。
public static final int MULTILINE
在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一致性：兼容性属性。
的unicode_character_class模式也可以通过嵌入国旗表达 (?U)启用。
国旗意味着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大于零则模式将被应用最多N - 1次，数组的长度将不大于n，和数组的最后一项将包含所有输入超出最后匹配的分隔符。如果n是非正的，那么该模式将被应用尽可能多的时间和数组可以有任何长度。如果n是零，那么该模式将被应用尽可能多的时间，数组可以有任何长度，并尾随空字符串将被丢弃。
例如，输入"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)
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.