public final class Pattern
extends Object implements Serializable
| java.lang.Object | |
| ↳ | java.util.regex.Pattern |
正则表达式的编译表示。
指定为字符串的正则表达式必须首先编译到该类的实例中。 然后可以使用生成的模式创建一个Matcher对象，该对象可以匹配任意 character sequences与正则表达式。 参与比赛的所有国家都驻留在匹配器中，所以许多匹配者可以共享相同的模式。
因此典型的调用序列
Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); boolean b = m.matches();
一个matches方法被这个类定义为只使用一次正则表达式的便利。 该方法编译一个表达式并在一次调用中将输入序列与它进行匹配。 该声明
Android开发手册
boolean b = Pattern.matches("a*b", "aaaaab");
is equivalent to the three statements above, though for repeated matches it is less efficient since it does not allow the compiled pattern to be reused.
这个类的实例是不可变的，可以安全地用于多个并发线程。 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] |
| \s | A whitespace character: [ \t\n\x0B\f\r] |
| \S | A non-whitespace character: [^\s] |
| \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 |
| 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 |
反斜杠字符（ '\' ）用于引入上表中定义的转义结构，并引用将被解释为未转义结构的字符。 因此表达式\\匹配单个反斜杠， \{匹配左大括号。
在任何不表示转义构造的字母之前使用反斜杠是错误的; 这些保留用于未来对正则表达式语言的扩展。 在非字母字符之前可以使用反斜杠，而不管该字符是否是非转义构造的一部分。
Backslashes within string literals in Java source code are interpreted as required by The Java™ Language Specification as either Unicode escapes (section 3.3) or other character escapes (section 3.10.6) It is therefore necessary to double backslashes in string literals that represent regular expressions to protect them from interpretation by the Java bytecode compiler. The string literal "\b", for example, matches a single backspace character when interpreted as a regular expression, while "\\b" matches a word boundary. The string literal "\(hello\)" is illegal and leads to a compile-time error; in order to match the string (hello) the string literal "\\(hello\\)" must be used.
字符类可能会出现在其他字符类中，并且可能由联合运算符（隐式）和相交运算符（ && ）组成。 联合运算符表示一个类，它包含至少在其一个操作数类中的每个字符。 交点运算符表示一个类，它包含两个操作数类中的每个字符。
字符类运算符的优先级如下，从最高到最低：
1 Literal escape \x 2 Grouping [...] 3 Range a-z 4 Union [a-e][i-u] 5 Intersection [a-z&&[aeiou]]
Note that a different set of metacharacters are in effect inside a character class than outside a character class. For instance, the regular expression . loses its special meaning inside a character class, while the expression - becomes a range forming metacharacter.
行结束符是一个单字符或双字符序列，用于标记输入字符序列的一行的结尾。 以下是公认的行结束符：
If UNIX_LINES模式被激活，则唯一被识别的行终止符是换行符。
除非指定了 DOTALL标志，否则正则表达式 .与除行结束符之外的任何字符匹配。
默认情况下，正则表达式^和$忽略行结束符，并且只能分别匹配整个输入序列的开始和结束。 如果激活MULTILINE模式，则^匹配输入开始处和任何行终止符之后（输入结束处除外）。 当在MULTILINE模式下$恰好在行结束符或输入序列结束之前匹配时。
捕获组通过从左到右数开括号来进行编号。 例如，在表达式((A)(B(C)))中 ，有四个这样的组：
1 ((A)(B(C))) 2 (A) 3 (B(C)) 4 (C)
零组始终代表整个表达式。
Capturing groups are so named because, during a match, each subsequence of the input sequence that matches such a group is saved. The captured subsequence may be used later in the expression, via a back reference, and may also be retrieved from the matcher once the match operation is complete.
一个捕获组也可以分配一个“名称”，一个named-capturing group ，然后后面引用“名称”。 组名称由以下字符组成。 第一个字符必须是letter 。
A named-capturing group is still numbered as described in Group number 。
与组关联的捕获输入始终是该组最近匹配的子序列。 如果一组因为量化而第二次被评估，那么如果第二次评估失败，则其先前捕获的值（如果有的话）将被保留。 例如，将字符串"aba"与表达式(a(b)?)+匹配， 会将 第二组设置为"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属性，而如果输入有物业\P{ 道具 }不匹配。
The script names supported by Pattern are the valid script names accepted and defined by UnicodeScript.forName 。
The block names supported by Pattern are the valid block names accepted and defined by UnicodeBlock.forName 。
The supported categories are those of The Unicode Standard由Character类指定的版本。 类别名称是标准中定义的那些名称，既有规范性又有信息性。
Predefined Character classes and POSIX character classes are in conformance with the recommendation of Annex C: Compatibility Properties of Unicode Regular Expression 。
| 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}] |
| \W | A non-word character: [^\w] |
Pattern引擎执行传统的基于NFA的匹配，使用Perl 5中的有序 Pattern 。
这个类不支持Perl构造：
预定义的字符类（Unicode字符）
\h 水平空白
\H 非水平空白
\v 垂直空格
\V 非垂直空白
\R 任何Unicode的 换行顺序 \u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029]
反向引用结构 \g{ n }第 n 个 capturing group和 \g{ 名称 } named-capturing group 。
指定的字符结构 \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.
也可以看看：
Constants |
|
|---|---|
int |
CANON_EQ 启用规范等价。 |
int |
CASE_INSENSITIVE 启用不区分大小写的匹配。 |
int |
COMMENTS 允许模式中的空白和注释。 |
int |
DOTALL 启用dotall模式。 |
int |
LITERAL 启用模式的文字分析。 |
int |
MULTILINE 启用多行模式。 |
int |
UNICODE_CASE 启用Unicode感知案例折叠。 |
int |
UNICODE_CHARACTER_CLASS 启用Unicode版本的 预定义字符类和 POSIX字符类，如 Unicode Technical Standard #18: Unicode Regular Expression 附录C：兼容性属性所示 。 |
int |
UNIX_LINES 启用Unix线路模式。 |
Public methods |
|
|---|---|
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[] |
split(CharSequence input, int limit) 按照此模式的匹配拆分给定的输入序列。 |
String[] |
split(CharSequence input) 按照此模式的匹配拆分给定的输入序列。 |
Stream<String> |
splitAsStream(CharSequence input) 根据此模式的匹配创建来自给定输入序列的流。 |
String |
toString() 返回此模式的字符串表示形式。 |
Inherited methods |
|
|---|---|
 From class java.lang.Object
|
|
int CANON_EQ
启用规范等价。
当这个标志被指定时，如果且仅当它们的完整标准分解匹配时，两个字符才被认为匹配。 例如，表达式"a\u030A"将在指定此标志时与字符串"\u00E5"匹配。 默认情况下，匹配不考虑规范等价。
没有嵌入标志字符来启用规范等价。
指定此标志可能会导致性能损失。
常量值：128（0x00000080）
int CASE_INSENSITIVE
启用不区分大小写的匹配。
默认情况下，不区分大小写的匹配假定仅匹配US-ASCII字符集中的字符。 通过将UNICODE_CASE标志与此标志一起指定，可以启用Unicode意识到的不区分大小写的匹配。
不区分大小写的匹配也可以通过嵌入标志表达式 (?i)来启用。
指定此标志可能会造成轻微的性能损失。
常量值：2（0x00000002）
int COMMENTS
允许模式中的空白和注释。
在这种模式下，空白被忽略，并且直到行尾才会忽略以 #开头的嵌入注释。
评论模式也可以通过嵌入式标志表达式 (?x)来启用。
常量值：4（0x00000004）
int DOTALL
启用dotall模式。
在dotall模式下，表达式.匹配任何字符，包括行结束符。 默认情况下，该表达式不匹配行结束符。
Dotall模式也可以通过嵌入式标志表达式(?s)来启用。 （ s是“单行”模式的助记符，这就是在Perl中所称的。）
常量值：32（0x00000020）
int LITERAL
启用模式的文字分析。
当指定此标志时，指定模式的输入字符串将被视为一系列文字字符。 输入序列中的元字符或转义序列将没有特别的含义。
与此标志一起使用时，CASE_INSENSITIVE和UNICODE_CASE标志保持对匹配的影响。 其他标志变得多余。
没有嵌入标志字符来启用文字分析。
常量值：16（0x00000010）
int MULTILINE
启用多行模式。
在多行模式下，表达式^和$分别与行终止符或输入序列的末尾之后或之前匹配。 默认情况下，这些表达式只匹配整个输入序列的开始和结束。
多行模式也可以通过嵌入式标志表达式 (?m)来启用。
常量值：8（0x00000008）
int UNICODE_CASE
启用Unicode感知案例折叠。
如果指定了此标志，那么在由CASE_INSENSITIVE标志启用时，不区分大小写的匹配以与Unicode标准一致的方式完成。 默认情况下，不区分大小写的匹配假定仅匹配US-ASCII字符集中的字符。
支持Unicode的案例折叠也可以通过嵌入式标志表达式 (?u)来启用。
指定此标志可能会导致性能损失。
常量值：64（0x00000040）
int UNICODE_CHARACTER_CLASS
按照 Unicode Technical Standard #18: Unicode Regular Expression 附录C：兼容性属性启用Unicode版本的 预定义字符类和 POSIX字符类 。
这个标志对Android没有影响，总是使用unicode字符类。
常量值：256（0x00000100）
int UNIX_LINES
启用Unix线路模式。
在这种模式下，只有 '\n'行结束在 .，^，并 $行为的认可。
Unix线路模式也可以通过嵌入式标志表达式 (?d)来启用。
常数值：1（0x00000001）
Predicate<String> asPredicate ()
创建可用于匹配字符串的谓词。
| Returns | |
|---|---|
Predicate<String> |
The predicate which can be used for matching on a string |
Pattern compile (String regex)
将给定的正则表达式编译成模式。
| Parameters | |
|---|---|
regex |
String: The expression to be compiled |
| Returns | |
|---|---|
Pattern |
|
| Throws | |
|---|---|
PatternSyntaxException |
If the expression's syntax is invalid |
Pattern compile (String regex, int flags)
使用给定的标志将给定的正则表达式编译成模式。
| Parameters | |
|---|---|
regex |
String: The expression to be compiled |
flags |
int: Match flags, a bit mask that may include CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ, UNIX_LINES, LITERAL, UNICODE_CHARACTER_CLASS and COMMENTS |
| Returns | |
|---|---|
Pattern |
|
| Throws | |
|---|---|
IllegalArgumentException |
If bit values other than those corresponding to the defined match flags are set in flags |
PatternSyntaxException |
If the expression's syntax is invalid |
int flags ()
返回此模式的匹配标志。
| Returns | |
|---|---|
int |
The match flags specified when this pattern was compiled |
Matcher matcher (CharSequence input)
创建一个匹配器，将匹配给定的输入与这种模式。
| Parameters | |
|---|---|
input |
CharSequence: The character sequence to be matched |
| Returns | |
|---|---|
Matcher |
A new matcher for this pattern |
boolean matches (String regex, CharSequence input)
编译给定的正则表达式并尝试匹配给定的输入。
这种方便的表单调用
behaves in exactly the same way as the expressionPattern.matches(regex, input);
Pattern.compile(regex).matcher(input).matches()
如果要多次使用某个模式，编译一次并重用它将比每次调用此方法更有效。
| Parameters | |
|---|---|
regex |
String: The expression to be compiled |
input |
CharSequence: The character sequence to be matched |
| Returns | |
|---|---|
boolean |
|
| Throws | |
|---|---|
PatternSyntaxException |
If the expression's syntax is invalid |
String pattern ()
返回编译该模式的正则表达式。
| Returns | |
|---|---|
String |
The source of this pattern |
String quote (String s)
返回面值模式 String指定的 String 。
此方法生成一个 String ，可用于创建 Pattern ，该字符串将与字符串 s匹配，就好像它是文字模式一样。
| Parameters | |
|---|---|
s |
String: The string to be literalized |
| Returns | |
|---|---|
String |
A literal string replacement |
String[] split (CharSequence input, int limit)
按照此模式的匹配拆分给定的输入序列。
此方法返回的数组包含输入序列的每个子字符串，该子字符串由与此模式匹配的另一个子序列终止，或者由输入序列的末尾终止。 数组中的子字符串按输入中的顺序排列。 如果这个模式不匹配输入的任何子序列，那么结果数组只有一个元素，即字符串形式的输入序列。
limit参数控制模式应用的次数，因此影响结果数组的长度。 如果极限值n大于零，那么模式将最多应用n -1次，数组的长度不会大于n ，并且数组的最后一项将包含超出最后匹配分隔符的所有输入。 如果n是非正值，那么该模式将尽可能多地应用，并且该数组可以具有任何长度。 如果n为零，则模式将尽可能多次应用，数组可以有任意长度，并且尾随的空字符串将被丢弃。
例如，输入 "boo:and:foo"通过这些参数得出以下结果：
正则表达式
限制
结果
: 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" }
| Parameters | |
|---|---|
input |
CharSequence: The character sequence to be split |
limit |
int: The result threshold, as described above |
| Returns | |
|---|---|
String[] |
The array of strings computed by splitting the input around matches of this pattern |
String[] split (CharSequence input)
按照此模式的匹配拆分给定的输入序列。
此方法的工作原理与通过调用具有给定输入序列和极限参数为零的双参数split方法一样。 尾随的空字符串因此不包含在结果数组中。
例如，输入 "boo:and:foo"用以下表达式得出以下结果：
正则表达式
结果
: { "boo", "and", "foo" } o { "b", "", ":and:f" }
| Parameters | |
|---|---|
input |
CharSequence: The character sequence to be split |
| Returns | |
|---|---|
String[] |
The array of strings computed by splitting the input around matches of this pattern |
Stream<String> splitAsStream (CharSequence input)
根据此模式的匹配创建来自给定输入序列的流。
此方法返回的流包含输入序列的每个子字符串，该子字符串由与此模式匹配的另一个子序列终止，或者由输入序列的结尾终止。 流中的子字符串按输入中的顺序排列。 尾随的空字符串将被丢弃并且不会在流中遇到。
如果这个模式不匹配输入的任何子序列，那么结果流只有一个元素，即字符串形式的输入序列。
如果在输入序列的开始处存在正宽度匹配，则在流的开始处包含一个空的前导子字符串。 然而，在开始处的零宽度匹配从不产生这样的空领先子字符串。
如果输入序列是可变的，则在执行终端流操作期间它必须保持不变。 否则，终端流操作的结果是未定义的。
| Parameters | |
|---|---|
input |
CharSequence: The character sequence to be split |
| Returns | |
|---|---|
Stream<String> |
The stream of strings computed by splitting the input around matches of this pattern |
也可以看看：
String toString ()
返回此模式的字符串表示形式。 这是编译此模式的正则表达式。
| Returns | |
|---|---|
String |
The string representation of this pattern |