Module  java.base
软件包  java.util.regex

Class Pattern

  • All Implemented Interfaces:
    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 !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ \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运算符表示一个包含至少一个操作数类中的每个字符的类。 交点运算符表示包含两个操作数类中的每个字符的类。

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

    Precedence of character class operators.
    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))) ，例如，有四个这样的组：

    Capturing group numberings
    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' ），

    A named-capturing group仍然编号如Group number所述 。

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

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

    Unicode支持

    该课程符合Unicode Technical Standard #18: Unicode Regular Expression的 1 级 ，加上RL2.1规范等同。

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

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

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

    Unicode extended grapheme clusters由图形集群匹配器\X和对应的边界匹配器\b{g} 。

    Unicode脚本，块，类别和二进制属性用Perl中的\p和\P结构编写。 \p{ 道具 }比赛如果输入有prop属性，而\P{ 道具 }如果输入有属性不匹配。

    脚本，块，类别和二进制属性可以在字符类的内部和外部使用。

    Scripts被指定为前缀Is ，如IsHiragana或script关键字（或其简称sc ），如script=Hiragana或sc=Hiragana 。

    所支持的脚本名称Pattern是接受和定义的有效脚本名称UnicodeScript.forName 。

    Blocks具有如InMongolian的前缀In或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的反斜杠转义的数字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)启用。

        另请参见：
        Constant Field Values

      • CASE_INSENSITIVE

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

        默认情况下，不区分大小写的匹配假定仅匹配US-ASCII字符集中的字符。 可以通过与此标志一起指定UNICODE_CASE标志来启用Unicode感知不区分大小写的匹配。

        也可以通过嵌入式标志表达式(?i)启用不区分大小写的匹配。

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

        另请参见：
        Constant Field Values

      • COMMENTS

        public static final int COMMENTS
        允许空格和注释格式。

        在此模式下，将忽略空格，并且以#开头的嵌入式注释#被忽略，直到行尾。

        注释模式也可以通过嵌入式标志表达式(?x)启用。

        另请参见：
        Constant Field Values

      • MULTILINE

        public static final int MULTILINE
        启用多行模式。

        在多行模式中，表达式^和$匹配行终止符或输入序列的结尾。 默认情况下，这些表达式仅在整个输入序列的开头和结尾匹配。

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

        另请参见：
        Constant Field Values

      • LITERAL

        public static final int LITERAL
        启用模式的文字解析。

        当指定此标志时，指定模式的输入字符串将被视为文字字符序列。 输入序列中的元字符或转义序列将没有特殊的含义。

        CASE_INSENSITIVE和UNICODE_CASE标志在与此标志一起使用时保持对匹配的影响。 其他旗帜变得多余。

        没有嵌入的标志字符用于启用文字解析。

        从以下版本开始：
        1.5
        另请参见：
        Constant Field Values

      • DOTALL

        public static final int DOTALL
        启用点阵模式。

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

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

        另请参见：
        Constant Field Values

      • UNICODE_CASE

        public static final int UNICODE_CASE
        启用Unicode感知案例折叠。

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

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

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

        另请参见：
        Constant Field Values

      • CANON_EQ

        public static final int CANON_EQ
        实现规范等价。

        当指定这个标志时，两个字符将被认为是匹配的，只有当他们的完整的规范分解符合时才匹配。 例如，当指定此标志时，表达式"a\u030A"将匹配字符串"\u00E5" 。 默认情况下，匹配不考虑规范等价。

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

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

        另请参见：
        Constant Field Values

      • 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
        另请参见：
        Constant Field Values

    • 方法详细信息

      • 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参数控制应用模式的次数，因此影响生成的数组的长度。 如果极限n大于0，则模式最多应用n -1次，数组的长度不大于n ，数组的最后一个条目将包含超出最后一个匹配分隔符的所有输入。 如果n是非正的，那么模式将被应用到尽可能多的次数，并且数组可以有任何长度。 如果n为0，则模式将被应用尽可能多次，数组可以有任何长度，并且尾随的空字符串将被丢弃。

        输入"boo:and:foo" ，例如，使用以下参数产生以下结果：

        Split examples 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", "", "" }
        o -2 { "b", "", ":and:f", "", "" }
        o 0 { "b", "", ":and:f" }
        参数
        input - 要分割的字符序列
        limit - 结果阈值，如上所述
        结果
        通过将输入围绕该模式的匹配分割来计算的字符串数组

      • split

        public String[] split​(CharSequence input)
        将给定的输入序列分成这个模式的匹配。

        该方法的工作原理是通过调用具有给定输入序列和限制参数为零的双参数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​()
        创建可用于匹配字符串的谓词。
        结果
        可用于匹配字符串的谓词
        从以下版本开始：
        1.8

      • splitAsStream

        public Stream<String> splitAsStream​(CharSequence input)
        根据给定的输入序列创建一个流，该流与该模式匹配。

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

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

        当在输入序列的开始处存在正宽度匹配时，在流的开始处包含空的前导子串。 开始时的零宽度匹配不会产生这样的空的前导子串。

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

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