Regular expressions in Java

• Regular expression syntax
• • \
  • (^) (# _16)
  • $
  • *
  • +
  • ?
  • {n}
  • {n,}
  • {n, m}
  • ?
  • .
  • (pattern)
  • (? :pattern)
  • (? =pattern)
  • (? ! pattern)
  • (? <=pattern)
  • (? <! pattern)
  • x|y
  • [xyz]
  • [^xyz]
  • [a-z]
  • [^a-z]
  • [:name:]
  • [=elt=]
  • [.elt.]
  • \b
  • \B
  • \cx
  • \d
  • \D
  • \f
  • \n
  • \r
  • \s
  • \S
  • \t
  • \v
  • \w
  • \W
  • \xnn
  • \num
  • \n
  • \nm
  • \nml
  • \un
  • \p{P}
  • < \ \ >
  • (a)
  • |
• Regular expression usage scenarios
• • String substitution
  • • Matcher
    • • appendReplacement()
      • appendTail()
      • The sample
  • Character checking

Regular expression syntax

\

^

• Matches the start of the input string
• If you set the Multiline property of the RegExp object, ^ also matches the position after \n or \r

$

*

• Matches the preceding subexpression zero or more times

• Equivalent to {0}

• Example:

  • Zo * -z or ZO or zoo

+

?

• Matches the preceding subexpression zero or once

• Equivalent to {0, 1}

• Example:

  • do(es)? – do or does

{n}

{n,}

• Match at least n times. N is a non-negative integer

• O {0,} is equivalent to o*

• O {1,} is equivalent to o+

• Example:

  • O {2,} – Does not match Bob, but matches Looooog

{n, m}

?

• Non-greedy quantization: When this character is followed by any of the other modifiers *, +,? , {n}, {n,}, {n,m}, the matching mode is non-greedy

  • The non-greedy pattern is to match as few strings as possible
  • The regular expression defaults to greedy mode, which matches as many strings as possible

• Example:

  • o+? – Matches a single O in loooooog
  • O + – Matches all o’s of Loooooog

.

(pattern)

• Matches pattern and gets the matching substring, which is used for backward reference
• The Matches obtained can be obtained from the collection that generated Matches

(? :pattern)

(? =pattern)

• Positive affirmative prelookup: Matches the lookup string at the beginning of any string that matches pattern

• This is a non-fetch match, meaning that the match does not need to be fetched for later use

• Presearch does not consume characters. That is, at the beginning of a match, the next match search starts immediately after the last match occurs, rather than starting the match search from the character that contains the pre-check character

• Example:

  • Windows(? = 95 NT | | 98 | 2000) – can match Windows in Windows, but can not match the Windows 10 of Windows

(? ! pattern)

(? <=pattern)

• Reverse affirmative prelookup: Reverse matches the lookup string at any string that matches pattern

• Example:

  • (? < = 95 NT | | 98 | 2000) Windows – can match 2000 Windows in Windows, but can’t match ten Windows in Windows

(? <! pattern)

x|y

• Or match

• If not enclosed in parentheses, the range is the entire regular expression. Otherwise, it just matches the string in parentheses

• Example:

  • Z | food – z or food
  • | f (z) oo – zoo or foo

[xyz]

[^xyz]

• A collection of excluded characters. Matches any character not listed

• Example:

  • [^ ABC] – can match plin in plain

[a-z]

[^a-z]

• Exclude the range of type characters. Matches any character that is not in the specified range

• Example:

  • [^a-z] – Matches any character not in the range from a to z

[:name:]

[=elt=]

• Add or subtract characters equivalent to ELT in the current locale. Can only be used in square bracket expressions

[.elt.]

\b

• Matches word boundaries. That is, the position between words and Spaces

• Example:

  • Er \b – can match er in never, but not er in verb

\B

\cx

• Matches the control character specified by x

• The value of x must be a-Z or one of a-Z characters, otherwise c is considered A literal C character

• The value of the control character equals the minimum 5 bits of the value of x (remainder of decimal 32)

• Example:

  • \cM – Matches control-m or carriage return
  • \ca – \u001
  • \cb – \u002

\d

\D

• Matches a non-numeric character
• Equivalent to [^ 0-9]

\f

\n

• Matches a newline character
• Equivalent to \x0a and \cJ

\r

\s

• Matches any whitespace character
• Includes Spaces, tabs, page feeds, etc
• Equivalent to [\f\n\r\t\v]

\S

\t

• Matches a TAB character
• This is equivalent to \x0b and \cI

\v

\w

• Matches any word character including underscores
• Equivalent to [A Za – z0-9 _]

\W

\xnn

• Hexadecimal escape character sequence. Matches a character represented by two hexadecimal digits nn

• ASCII encoding can be used in regular expressions

• \x041 is equivalent to \x04&1

• Example:

  • \x41 – A

\num

\n

• Identifies an octal escape value or a backreference:

  • If at least n subexpression is obtained before \n, n is a backreference
  • Otherwise,n is an octal number 0-7. In this case,n is an octal escape value

\nm

\nml

• If n is an octal number 0-3, and both m and L are octal numbers 0-7, \ NML will match the octal escape value NML

\un

\p{P}

• A Unicode regular expression prefix

  • The lowercase P is a property, representing a Unicode property

  • The P in braces represents the punctuation character of one of the seven character attributes in the Unicode character set. There are six other attributes:

    • L:
    • M: Mark symbol. They don’t usually appear alone
    • Z: delimiter. Such as Spaces, line breaks and so on
    • S: symbols, such as mathematical symbols, currency symbols and so on
    • N: Numbers, such as Arabic numerals, Roman numerals and so on
    • C: Other characters

• Note: This syntax is not supported in JavaScript

< \ \ >

(a)

• Define the expression between (and) as a group group, and save characters that match the expression to a temporary region. A regular expression can hold up to nine such temporary regions, referenced using the \1 through \9 symbols

|

Regular expression usage scenarios

String substitution

Matcher

• The Matcher class provides four methods to replace a matching string with a specified string:

  • replaceAll()
  • replaceFirst()
  • appendReplacement()
  • appendTail()

• Focus on the appendReplacement() and appendTail() methods

appendReplacement()

appendTail()

• appendTail(StringBuffer sb):

  • Adds the remaining characters after the last match to a StringBuffer object

The sample

Character checking

• Example of regular expression verification