Most visited

Recently visited

Added in API level 1

Pattern

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方法被这个类定义为只使用一次正则表达式的便利。 该方法编译一个表达式并在一次调用中将输入序列与它进行匹配。 该声明

 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类的实例对于这样的用途是不安全的。

Summary of regular-expression constructs

*
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 !"#$%&'()*+,-./:;<=>[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 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, escapes, and quoting

反斜杠字符( '\' )用于引入上表中定义的转义结构,并引用将被解释为未转义结构的字符。 因此表达式\\匹配单个反斜杠, \{匹配左大括号。

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

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.

Character Classes

字符类可能会出现在其他字符类中,并且可能由联合运算符(隐式)和相交运算符( && )组成。 联合运算符表示一个类,它包含至少在其一个操作数类中的每个字符。 交点运算符表示一个类,它包含两个操作数类中的每个字符。

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

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.

Line terminators

行结束符是一个单字符或双字符序列,用于标记输入字符序列的一行的结尾。 以下是公认的行结束符:

  • A newline (line feed) character ('\n'),
  • A carriage-return character followed immediately by a newline character ("\r\n"),
  • A standalone carriage-return character ('\r'),
  • A next-line character ('\u0085'),
  • A line-separator character ('\u2028'), or
  • A paragraph-separator character ('\u2029).

If UNIX_LINES模式被激活,则唯一被识别的行终止符是换行符。

除非指定了 DOTALL标志,否则正则表达式 .与除行结束符之外的任何字符匹配。

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

Groups and capturing

Group number

捕获组通过从左到右数开括号来进行编号。 例如,在表达式((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.

Group name

一个捕获组也可以分配一个“名称”,一个named-capturing group ,然后后面引用“名称”。 组名称由以下字符组成。 第一个字符必须是letter

  • The uppercase letters 'A' through 'Z' ('\u0041' through '\u005a'),
  • The lowercase letters 'a' through 'z' ('\u0061' through '\u007a'),
  • The digits '0' through '9' ('\u0030' through '\u0039'),

A named-capturing group is still numbered as described in Group number

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

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

Unicode support

本课程符合 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{ 道具 }不匹配。

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

Scripts are specified either with the prefix Is, as in IsHiragana, or by using the script keyword (or its short form sc)as in script=Hiragana or sc=Hiragana.

The script names supported by Pattern are the valid script names accepted and defined by UnicodeScript.forName

Blocks are specified with the prefix In, as in InMongolian, or by using the keyword block (or its short form blk) as in block=Mongolian or blk=Mongolian.

The block names supported by Pattern are the valid block names accepted and defined by UnicodeBlock.forName

Categories may be specified with the optional prefix Is: Both \p{L} and \p{IsL} denote the category of Unicode letters. Same as scripts and blocks, categories can also be specified by using the keyword general_category (or its short form gc) as in general_category=Lu or gc=Lu.

The supported categories are those of The Unicode StandardCharacter类指定的版本。 类别名称是标准中定义的那些名称,既有规范性又有信息性。

Binary properties are specified with the prefix Is, as in IsAlphabetic. The supported binary properties by Pattern are

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]

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.

Comparison to Perl 5

Pattern引擎执行传统的基于NFA的匹配,使用Perl 5中的有序 Pattern

这个类不支持Perl构造:

这个类支持但不是Perl支持的构造:

来自Perl的显着差异:

有关正则表达式结构的更精确的描述,请参阅 Mastering Regular Expressions, 3nd Edition, Jeffrey E. F. Friedl, O'Reilly and Associates, 2006.

也可以看看:

Summary

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指定的 String

String[] split(CharSequence input, int limit)

按照此模式的匹配拆分给定的输入序列。

String[] split(CharSequence input)

按照此模式的匹配拆分给定的输入序列。

Stream<String> splitAsStream(CharSequence input)

根据此模式的匹配创建来自给定输入序列的流。

String toString()

返回此模式的字符串表示形式。

Inherited methods

From class java.lang.Object

Constants

CANON_EQ

Added in API level 1
int CANON_EQ

启用规范等价。

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

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

指定此标志可能会导致性能损失。

常量值:128(0x00000080)

CASE_INSENSITIVE

Added in API level 1
int CASE_INSENSITIVE

启用不区分大小写的匹配。

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

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

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

常量值:2(0x00000002)

COMMENTS

Added in API level 1
int COMMENTS

允许模式中的空白和注释。

在这种模式下,空白被忽略,并且直到行尾才会忽略以 #开头的嵌入注释。

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

常量值:4(0x00000004)

DOTALL

Added in API level 1
int DOTALL

启用dotall模式。

在dotall模式下,表达式.匹配任何字符,包括行结束符。 默认情况下,该表达式不匹配行结束符。

Dotall模式也可以通过嵌入式标志表达式(?s)来启用。 s是“单行”模式的助记符,这就是在Perl中所称的。)

常量值:32(0x00000020)

LITERAL

Added in API level 1
int LITERAL

启用模式的文字分析。

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

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

没有嵌入标志字符来启用文字分析。

常量值:16(0x00000010)

MULTILINE

Added in API level 1
int MULTILINE

启用多行模式。

在多行模式下,表达式^$分别与行终止符或输入序列的末尾之后或之前匹配。 默认情况下,这些表达式只匹配整个输入序列的开始和结束。

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

常量值:8(0x00000008)

UNICODE_CASE

Added in API level 1
int UNICODE_CASE

启用Unicode感知案例折叠。

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

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

指定此标志可能会导致性能损失。

常量值:64(0x00000040)

UNICODE_CHARACTER_CLASS

Added in API level 24
int UNICODE_CHARACTER_CLASS

按照 Unicode Technical Standard #18: Unicode Regular Expression 附录C:兼容性属性启用Unicode版本的 预定义字符类POSIX字符类

这个标志对Android没有影响,总是使用unicode字符类。

常量值:256(0x00000100)

UNIX_LINES

Added in API level 1
int UNIX_LINES

启用Unix线路模式。

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

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

常数值:1(0x00000001)

Public methods

asPredicate

Added in API level 24
Predicate<String> asPredicate ()

创建可用于匹配字符串的谓词。

Returns
Predicate<String> The predicate which can be used for matching on a string

compile

Added in API level 1
Pattern compile (String regex)

将给定的正则表达式编译成模式。

Parameters
regex String: The expression to be compiled
Returns
Pattern
Throws
PatternSyntaxException If the expression's syntax is invalid

compile

Added in API level 1
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

flags

Added in API level 1
int flags ()

返回此模式的匹配标志。

Returns
int The match flags specified when this pattern was compiled

matcher

Added in API level 1
Matcher matcher (CharSequence input)

创建一个匹配器,将匹配给定的输入与这种模式。

Parameters
input CharSequence: The character sequence to be matched
Returns
Matcher A new matcher for this pattern

matches

Added in API level 1
boolean matches (String regex, 
                CharSequence input)

编译给定的正则表达式并尝试匹配给定的输入。

这种方便的表单调用

 Pattern.matches(regex, input);
behaves in exactly the same way as the expression
 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

pattern

Added in API level 1
String pattern ()

返回编译该模式的正则表达式。

Returns
String The source of this pattern

quote

Added in API level 1
String quote (String s)

返回面值模式 String指定的 String

此方法生成一个 String ,可用于创建 Pattern ,该字符串将与字符串 s匹配,就好像它是文字模式一样。

Metacharacters or escape sequences in the input sequence will be given no special meaning.

Parameters
s String: The string to be literalized
Returns
String A literal string replacement

split

Added in API level 1
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

split

Added in API level 1
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

splitAsStream

Added in API level 24
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

也可以看看:

toString

Added in API level 1
String toString ()

返回此模式的字符串表示形式。 这是编译此模式的正则表达式。

Returns
String The string representation of this pattern

Hooray!