Regular Expressions

Regular expressions are a way to describe a set of strings based on common characteristics shared by each string in the set. They can be used to search, edit, or manipulate text and data.

RegEx in Java

The java.util.regex package primarily consists of three classes: Pattern, Matcher, and PatternSyntaxException.

• A Pattern object is a compiled representation of a regular expression. The Pattern class provides no public constructors. To create a pattern, you must first invoke one of its public static compile methods, which will then return a Pattern object. These methods accept a regular expression as the first argument; the first few lessons of this trail will teach you the required syntax.
• A Matcher object is the engine that interprets the pattern and performs match operations against an input string. Like the Pattern class, Matcher defines no public constructors. You obtain a Matcher object by invoking the matcher method on a Pattern object.
• A PatternSyntaxException object is an unchecked exception that indicates a syntax error in a regular expression pattern.

A test class for using the regex,

import java.io.Console;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexTest {

    public static void main(String[] args){
        Console console = System.console();
        if (console == null) {
            System.err.println("No console.");
            System.exit(1);
        }
        while (true) {

            Pattern pattern =
            Pattern.compile(console.readLine("%nEnter your regex: "));

            Matcher matcher =
            pattern.matcher(console.readLine("Enter input string to search: "));

            boolean found = false;
            while (matcher.find()) {
                console.format("I found the text \"%s\" starting at " +
                   "index %d and ending at index %d.%n",
                    matcher.group(), matcher.start(), matcher.end());
                found = true;
            }
            if(!found){
                console.format("No match found.%n");
            }
        }
    }
}
 Summary of regular-expression constructs 

 


<!-- [\!"#\$%&'\(\)\*\+,\-\./:;\\?@\[\\\]\^_`\{\|\}~][\X21-\X2F\X31-\X40\X5B-\X60\X7B-\X7E] -->


<!-- Metachars: !$()*+.?[\]^{|} -->



Construct
Matches





Characters


x
The character x


\\
The backslash character


n
The character with octal value 0n (0 <= n <= 7)


nn
The character with octal value 0nn (0 <= n <= 7)


mnn
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


\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 !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
 

\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  blocks and categories


\p{InGreek}
A character in the Greek block (simple block)


\p{Lu}
An uppercase letter (simple category)


\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


(?idmsux-idmsux) 
Nothing, but turns match flags i d m s u x 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

Advertisement