模块  java.base
软件包  java.util.regex

Class Pattern

  • 实现的所有接口
    Serializable 
    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类的实例不适合此类使用。

    Summary of regular-expression constructs

    Regular expression constructs, and what they match 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) \N{name} The character with Unicode character name 'name' \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 !"#$%&'()*+,-./:;<=>[email protected][\]^_`{|}~ \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{g} A Unicode extended grapheme cluster 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] Unicode Extended Grapheme matcher \X Any Unicode extended grapheme cluster 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, escapes, and quoting

    反斜杠字符（ '\' ）用于引入如上表中定义的转义构造，以及引用否则将被解释为非转义构造的字符。 因此，表达式\\匹配单个反斜杠， \{匹配左括号。

    在任何不表示转义构造的字母字符之前使用反斜杠是错误的; 这些保留用于将来对正则表达式语言的扩展。 无论该字符是否是未转义构造的一部分，都可以在非字母字符之前使用反斜杠。

    Java源代码中字符串文字中的反斜杠被The Java™ Language Specification解释为Unicode转义（第3.3节）或其他字符转义（第3.10.6节）。因此，必须在表示正则表达式的字符串文字中加倍反斜杠以保护它们免受由Java字节码编译器解释。 例如，字符串文字"\b"在解释为正则表达式时匹配单个退格字符，而"\\b"与单词边界匹配。 字符串文字"\(hello\)"是非法的，并导致编译时错误; 为了匹配字符串(hello) ，必须使用字符串文字"\\(hello\\)" 。

    Character Classes

    字符类可以出现在其他字符类中，并且可以由union运算符（隐式）和交集运算符（ && ）组成。 union运算符表示一个类，它包含至少一个操作数类中的每个字符。 交集运算符表示一个类，它包含两个操作数类中的每个字符。

    字符类运算符的优先级如下，从最高到最低：

    Precedence of character class operators. Precedence Name Example 1 Literal escape     \x 2 Grouping [...] 3 Range a-z 4 Union [a-e][i-u] 5 Intersection [a-z&&[aeiou]]

    请注意，字符类中的一组不同的元字符在字符类外部有效。 例如，正则表达式.在字符类中失去其特殊含义，而表达式-变为形成元字符的范围。

    Line terminators

    行终止符是一个或两个字符的序列，用于标记输入字符序列的一行的结尾。 以下被认为是行终止符：

    • 换行符（换行符）（ '\n' ），
    • 一个回车符后面跟一个换行符（ "\r\n" ），
    • 一个独立的回车符（ '\r' ），
    • 下一行字符（ '\u0085' ），
    • 行分隔符（ '\u2028' ），或
    • 段落分隔符（ '\u2029' ）。

    如果激活UNIX_LINES模式，则识别的唯一行终止符是换行符。

    除非指定了DOTALL标志，否则正则表达式.匹配除行终止符之外的任何字符。

    默认情况下，正则表达式^和$忽略行终止符，并且仅分别匹配整个输入序列的开头和结尾。 如果激活MULTILINE模式，则^在输入开始时和任何行终止符之后匹配，但输入结束时除外。 当处于MULTILINE模式时， $匹配在行终止符之前或输入序列的结尾。

    Groups and capturing

    Group number

    捕获组通过从左到右计算它们的左括号来编号。 例如，在表达式((A)(B(C))) ，有四个这样的组：

    1. ((A)(B(C)))
    2. (A)
    3. (B(C))
    4. (C)

    组零始终代表整个表达式。

    捕获组是如此命名的，因为在匹配期间，保存与该组匹配的输入序列的每个子序列。 捕获的子序列可以稍后在表达式中通过后向引用使用，并且一旦匹配操作完成，也可以从匹配器中检索。

    Group name

    还可以为捕获组分配“名称”， named-capturing group ，然后通过“名称”对其进行反向引用。 组名由以下字符组成。 第一个字符必须是letter 。

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

    甲named-capturing group如描述仍然编号Group number 。

    与组关联的捕获输入始终是该组最近匹配的子序列。 如果由于量化而第二次评估组，则如果第二次评估失败，则将保留其先前捕获的值（如果有的话）。 例如，将字符串"aba"与表达式(a(b)?)+匹配，将第二组设置为"b" 。 在每次比赛开始时丢弃所有捕获的输入。

    以(?开头的组是纯捕获组，不捕获文本且不计入组总数或命名捕获组。

    Unicode支持

    本课程符合第1级Unicode Technical Standard #18: Unicode Regular Expression ，加上RL2.1规范等效。

    如Unicode转义序列 \u2014在Java源代码作为的The Java™ Language Specification第3.3节描述的进行处理。 这种转义序列也可以由正则表达式解析器直接实现，这样Unicode转义就可以用在从文件或键盘读取的表达式中。 因此，字符串"\u2014"和"\\u2014"虽然不相等，但是编译成相同的模式，其匹配具有十六进制值0x2014的字符。

    Unicode字符也可以通过使用其十六进制表示法 （十六进制代码点值）直接表示，如构造\x{...} ，例如，补充字符U + 2011F可以指定为\x{2011F} ，而不是代理对的两个连续Unicode转义序列\uD840 \uDD1F 。

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

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

    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 ）指定类别，如general_category=Lu或gc=Lu 。

    支持的类别是那些The Unicode Standard由指定的版本Character类。 类别名称是标准中定义的类别，包括规范性和信息性。

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

    • 拼音
    • 表意的
    • 信件
    • 小写
    • 大写
    • 首字母大写
    • 标点
    • 控制
    • White_Space
    • 数字
    • 16进制数字
    • Join_Control
    • Noncharacter_Code_Point
    • 分配

    以下预定义字符类和POSIX字符类符合附录C的建议： Unicode Regular Expression 的 兼容性属性 ，当指定UNICODE_CHARACTER_CLASS标志时。

    predefined and posix character classes in Unicode mode 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]

    Categories that behave like the java.lang.Character boolean ismethodname methods (except for the deprecated ones) are available through the same \p{prop} syntax where the specified property has the name javamethodname 。

    与Perl 5的比较

    Pattern引擎执行传统的基于NFA的匹配，具有Perl 5中的有序交替。

    此类不支持的Perl构造：

    • 反向引用构造， \g{ ñ } 第 n 个 capturing group和\g{ 名 }为named-capturing group 。

    • 条件构造(?( 条件 ) 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.

    从以下版本开始：
    1.4
    另请参见：
    String.split(String, int) ， String.split(String) ， Serialized Form

    • 字段详细信息

      • UNIX_LINES

        public static final int UNIX_LINES
        启用Unix线路模式。

        在这种模式下，只有'\n'行结束在行为认可. ， ^和$ 。

        Unix行模式也可以通过嵌入式标志表达式(?d)启用。

        另请参见：
        常数字段值

      • CASE_INSENSITIVE

        public static final int CASE_INSENSITIVE
        启用不区分大小写的匹配。

        默认情况下，不区分大小写的匹配假定只匹配US-ASCII字符集中的字符。 通过将UNICODE_CASE标志与此标志一起指定，可以启用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
        另请参见：
        常数字段值

      • DOTALL

        public static final int DOTALL
        启用dotall模式。

        在dotall模式下，表达式.匹配任何字符，包括行终止符。 默认情况下，此表达式与行终止符不匹配。

        也可以通过嵌入式标志表达式(?s)启用Dotall模式。 （ s是“单行”模式的助记符，这是在Perl中调用的。）

        另请参见：
        常数字段值

      • UNICODE_CASE

        public static final int UNICODE_CASE
        启用支持Unicode的案例折叠。

        指定此标志时，由CASE_INSENSITIVE标志启用时，不区分大小写的匹配将以与Unicode标准一致的方式完成。 默认情况下，不区分大小写的匹配假定只匹配US-ASCII字符集中的字符。

        也可以通过嵌入式标志表达式(?u)启用支持Unicode的案例折叠。

        指定此标志可能会造成性能损失。

        另请参见：
        常数字段值

      • CANON_EQ

        public static final int CANON_EQ
        启用规范等效。

        指定此标志时，如果且仅当它们的完整规范分解匹配时，将认为两个字符匹配。 例如，当指定此标志时，表达式"a\u030A"将匹配字符串"\u00E5" 。 默认情况下，匹配不会将规范等效性考虑在内。

        没有用于启用规范等价的嵌入标志字符。

        指定此标志可能会造成性能损失。

        另请参见：
        常数字段值

      • UNICODE_CHARACTER_CLASS

        public static final int UNICODE_CHARACTER_CLASS
        启用Unicode版本的预定义字符类和POSIX字符类 。

        指定此标志后，（仅限US-ASCII） 预定义字符类和POSIX字符类符合Unicode Technical Standard #18: Unicode Regular Expression 附录C：兼容性属性 。

        也可以通过嵌入式标志表达式(?U)启用UNICODE_CHARACTER_CLASS模式。

        该标志意味着UNICODE_CASE，也就是说，它启用了Unicode感知的案例折叠。

        指定此标志可能会造成性能损失。

        从以下版本开始：
        1.7
        另请参见：
        常数字段值

    • 方法详细信息

      • compile

        public static Pattern compile​(String regex)
        将给定的正则表达式编译为模式。
        参数
        regex - 要编译的表达式
        结果
        将给定的正则表达式编译成模式
        异常
        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"使用以下参数产生以下结果：

        Split example showing regex, limit, and result Regex Limit Result : 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)
        围绕此模式的匹配拆分给定的输入序列。

        此方法的工作方式就像调用具有给定输入序列和limit参数为零的双参数split方法一样。 因此，结尾的空字符串不包含在结果数组中。

        例如，输入"boo:and:foo"使用以下表达式产生以下结果：

        Split examples showing regex and result Regex Result : { "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 Note:
        此方法创建一个谓词，其行为就像从输入序列创建匹配器，然后调用find ，例如表单的谓词： 
           s -> matcher(s).find();
        结果
        可用于在字符串的子序列中查找匹配的谓词
        从以下版本开始：
        1.8
        另请参见：
        Matcher.find()

      • asMatchPredicate

        public Predicate<String> asMatchPredicate()
        创建一个谓词，测试此模式是否与给定的输入字符串匹配。
        API Note:
        此方法创建一个谓词，其行为就像从输入序列创建匹配器，然后调用matches ，例如表单的谓词： 
           s -> matcher(s).matches();
        结果
        可用于将输入字符串与此模式进行匹配的谓词。
        从以下版本开始：
        11
        另请参见：
        Matcher.matches()

      • splitAsStream

        public Stream<String> splitAsStream​(CharSequence input)
        围绕此模式的匹配从给定输入序列创建流。

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

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

        当在输入序列的开头存在正宽度匹配时，在流的开头包括空的前导子串。 然而，开头的零宽度匹配从不会产生这样的空前导子串。

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

        参数
        input - 要拆分的字符序列
        结果
        通过在该模式的匹配周围分割输入来计算的字符串流
        从以下版本开始：
        1.8
        另请参见：
        split(CharSequence)