Java Regular Expressions

The regular expression defines the pattern of the string. is a specification that can be used for pattern matching and substitution, which can be understood as a matching rule . A regular expression is a text pattern consisting of ordinary characters (such as characters A through Z) and special characters (metacharacters). Jdk1.4 launched the Java.util.regex package.

The Java.util.regex package mainly consists of the following three classes:

Pattern class:

The pattern object is a compiled representation of a regular expression. The pattern class has no public constructor method. To create a pattern object, you must first call its public static compilation method, which returns a Pattern object. The method takes a regular expression as its first argument.

　　An explanation of the pattern in the API:

The compiled representation of the regular expression.

A regular expression that is specified as a string must first be compiled into an instance of this class. The resulting pattern can then be used to create an Matcher object that, according to the regular expression, can match any sequence of characters . All the states involved in performing a match reside in the match, so multiple matches can share the same pattern.

Therefore, the typical invocation order is

Pattern p = pattern. compile ("A*b"); Matcher m = p. matcher ("Aaaaab"); Boolean b = M. matches ();

This class is a convenient way to define a method when you use only one regular expression matches . This method compiles an expression and matches the input sequence in a single call. Statement

Boolean B = pattern.matches ("A*b", "Aaaaab");

is equivalent to the three statements above, although it is inefficient for duplicate matches because it does not allow the reuse of compiled schemas.

Instances of this class are immutable and can be used safely by multiple concurrent threads. The Matcher instance of the class is not secure for this purpose.

Matcher class:

The Matcher object is the engine that interprets and matches the input string. Like the pattern class, Matcher does not have a public construction method. You need to invoke the Matcher method of the Pattern object to get a Matcher object.

　　Explanation of the Matcher in the API:

　　By explaining Pattern the engine that performs the matching operation on the character sequence.

Creates a match from a pattern by invoking the mode's matcher method. After you create a match, you can use it to perform three different matching operations:

• • matchesMethod attempts to match the entire input sequence to the pattern.

  • lookingAtAttempts to match the input sequence to the pattern from the beginning.

  • findmethod to scan the input sequence to find the next subsequence that matches the pattern.

Each method returns a Boolean value that represents success or failure. You can get more information about a successful match by querying the status of the match.

Patternsyntaxexception:

Patternsyntaxexception is a non-mandatory exception class that represents a syntax error in a regular expression pattern.

Regular expression Syntax:

Character	Description
\	Marks the next character as a special character, text, reverse reference, or octal escape. For example, "n" matches the character "n". "\ n" matches the line break. The sequence "\ \" matches "\", "\ (" Match "(".
^	Matches the starting position of the input string. If the Multiline property of the RegExp object is set, ^ will also match the position after "\ n" or "\ r".
$	Matches the position of the end of the input string. If you set the Multiline property of the RegExp object, the $ will also match the position before \ n or \ r.
*	Matches the preceding character or sub-expression 0 or more times. For example, zo* matches "z" and "Zoo". * Equivalent to {0,}.
+	Matches the preceding character or sub-expression one or more times. For example, "zo+" matches "Zo" and "Zoo", but does not match "Z". + equivalent to {1,}.
?	Matches the preceding character or sub-expression 0 or one time. For example, "Do (es)?" Match "Do" in "do" or "does".? Equivalent to {0,1}.
{n}	N is a non-negative integer. Matches exactly N times. For example, "o{2}" does not match "O" in "Bob", but matches two "o" in "food".
{n,}	N is a non-negative integer. Match at least N times. For example, "o{2,}" does not match "O" in "Bob", but matches all o in "Foooood". "O{1,}" is equivalent to "o+". "O{0,}" is equivalent to "o*".
{n,m}	m and n are non-negative integers, where n <= M. Matches at least N times, up to m times. For example, "o{1,3}" matches the first three o in "Fooooood". ' o{0,1} ' is equivalent to ' O? '. Note: You cannot insert a space between a comma and a number.
?	When this character follows any other qualifier (*, + 、?、 {n}, {n,}, {n,m}), the matching pattern is "non-greedy". The "non-greedy" pattern matches the shortest possible string searched, while the default "greedy" pattern matches the string that is searched for as long as possible. For example, in the string "Oooo", "o+?" Only a single "O" is matched, and "o+" matches All "O".
.	Matches any single character except for "\ r \ n". To match any character that includes "\ r \ n", use a pattern such as "[\s\s]".
(pattern)	Matches the pattern and captures the matched sub-expression. You can use the $0...$9 property to retrieve a captured match from the result "match" collection. To match the bracket character (), use "\ (" or "\)".
(?:pattern)	A subexpression that matches the pattern but does not capture the match, that is, it is a non-capturing match and does not store a match for later use. This is useful for combining pattern parts with the "or" character (|). For example, ' Industr (?: y|ies) is a more economical expression than ' industry|industries '.
(? =pattern)	A subexpression that performs a forward lookahead search that matches the string at the starting point of the string that matches the pattern . It is a non-capture match, that is, a match that cannot be captured for later use. For example, ' Windows (? =95|98| nt|2000) ' Matches Windows 2000 ' in Windows, but does not match Windows 3.1 in Windows. Lookahead does not occupy characters, that is, when a match occurs, the next matching search immediately follows the previous match, rather than the word specifier that makes up the lookahead.
(?! pattern)	A subexpression that performs a reverse lookahead search that matches a search string that is not at the starting point of a string that matches the pattern . It is a non-capture match, that is, a match that cannot be captured for later use. For example, ' Windows (?! 95|98| nt|2000) ' matches Windows 3.1 ' in Windows, but does not match Windows 2000 in Windows. Lookahead does not occupy characters, that is, when a match occurs, the next matching search immediately follows the previous match, rather than the word specifier that makes up the lookahead.
x| y	Match x or y. For example, ' Z|food ' matches ' z ' or ' food '. ' (z|f) Ood ' matches "Zood" or "food".
[XYZ]	Character. Matches any one of the characters contained. For example, "[ABC]" matches "a" in "plain".
[^XYZ]	The reverse character set. Matches any characters that are not contained. For example, "[^abc]" matches "plain" in "P", "L", "I", "N".
[A-Z]	The character range. Matches any character within the specified range. For example, "[A-z]" matches any lowercase letter in the range "a" to "Z".
[^ A-Z]	The inverse range character. Matches any character that is not in the specified range. For example, "[^a-z]" matches any character that is not in the range "a" to "Z".
\b	Matches a word boundary, which is the position between the word and the space. For example, "er\b" matches "er" in "never", but does not match "er" in "verb".
\b	Non-word boundary match. "er\b" matches "er" in "verb", but does not match "er" in "Never".
\cx	Matches the control character indicated by x . For example, \cm matches a control-m or carriage return character. The value of x must be between A-Z or a-Z. If this is not the case, then the C is assumed to be the "C" character itself.
\d	numeric character matching. equivalent to [0-9].
\d	Non-numeric character matching. equivalent to [^0-9].
\f	The page break matches. Equivalent to \x0c and \CL.
\ n	Line break matches. Equivalent to \x0a and \CJ.
\ r	Matches a carriage return character. Equivalent to \x0d and \cm.
\s	Matches any whitespace character, including spaces, tabs, page breaks, and so on. equivalent to [\f\n\r\t\v].
\s	Matches any non-whitespace character. equivalent to [^ \f\n\r\t\v].
\ t	TAB matches. Equivalent to \x09 and \ci.
\v	Vertical tab matches. Equivalent to \x0b and \ck.
\w	Matches any character, including underscores. Equivalent to "[a-za-z0-9_]".
\w	Matches any non-word character. Equivalent to "[^a-za-z0-9_]".
\xN	Match N, where n is a hexadecimal escape code. The hexadecimal escape code must be exactly two digits long. For example, "\x41" matches "A". "\x041" is equivalent to "\x04" & "1". Allows the use of ASCII code in regular expressions.
\Num	Matches num, where num is a positive integer. To capture a matching reverse reference. For example, "(.) \1 "matches two consecutive identical characters.
\N	Identifies an octal escape code or a reverse reference. If there are at least N captured subexpression in front of \n , then n is a reverse reference. Otherwise, if n is an octal number (0-7), then n is the octal escape code.
\nm	Identifies an octal escape code or a reverse reference. If there is at least a nm capture subexpression in front of the \nm , then nm is a reverse reference. If there are at least N captures in front of the \nm , then n is a reverse reference followed by the character M. If neither of the preceding conditions exists, the \nm matches the octal value nm, where n and m are octal digits (0-7).
\NML	When N is an octal number (0-3),m and l are octal numbers (0-7), the octal escape code NMLis matched.
\uN	Matches n, where n is a Unicode character represented by a four-bit hexadecimal number. For example, \u00a9 matches the copyright symbol (©).

(about regular expressions, there are many, later in a little finishing ...)

Java Regular Expressions