JAVA - REGULAR EXPRESSIONS
http://www.tutorialspoint.com/java/java_regular_expressions.htm Copyright © tutorials point.com
Java provides t he java.ut il.regex package for pat t ern mat ching wit h regular expressions. Java regular
expressions are very similar t o t he Perl programming language and very easy t o learn.
A regular expression is a special sequence of charact ers t hat helps you mat ch or find ot her st rings or
set s of st rings, using a specialized synt ax held in a pat t ern. They can be used t o search, edit , or
manipulat e t ext and dat a.
The java.ut il.regex package primarily consist s of t he following t hree classes:
Pattern Class: A Pat t ern object is a compiled represent at ion of a regular expression. The
Pat t ern class provides no public const ruct ors. To creat e a pat t ern, you must first invoke one
of it s public st at ic compile met hods, which will t hen ret urn a Pat t ern object . These met hods
accept a regular expression as t he first argument .
Matcher Class: A Mat cher object is t he engine t hat int erpret s t he pat t ern and performs
mat ch operat ions against an input st ring. Like t he Pat t ern class, Mat cher defines no public
const ruct ors. You obt ain a Mat cher object by invoking t he mat cher met hod on a Pat t ern
object .
PatternSyntaxExceptio n: A Pat t ernSynt axExcept ion object is an unchecked except ion
t hat indicat es a synt ax error in a regular expression pat t ern.
Capt uring Groups:
Capt uring groups are a way t o t reat mult iple charact ers as a single unit . They are creat ed by placing
t he charact ers t o be grouped inside a set of parent heses. For example, t he regular expression (dog)
creat es a single group cont aining t he let t ers "d", "o", and "g".
Capt uring groups are numbered by count ing t heir opening parent heses from left t o right . In t he
expression ((A)(B(C))), for example, t here are four such groups:
((A)(B(C)))
(A)
(B(C))
(C)
To find out how many groups are present in t he expression, call t he groupCount met hod on a
mat cher object . The groupCount met hod ret urns an int showing t he number of capt uring groups
present in t he mat cher's pat t ern.
There is also a special group, group 0, which always represent s t he ent ire expression. This group is
not included in t he t ot al report ed by groupCount .
Example:
Following example illust rat es how t o find a digit st ring from t he given alphanumeric st ring:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
public static void main( String args[] ){
// String to be scanned to find the pattern.
String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\\d+)(.*)";
// Create a Pattern object
Pattern r = Pattern.compile(pattern);
// Now create matcher object.
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
} else {
System.out.println("NO MATCH");
}
}
}
This would produce t he following result :
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0
Regular Expression Synt ax:
Here is t he t able list ing down all t he regular expression met acharact er synt ax available in Java:
Subexpressio n Matches
^ Mat ches beginning of line.
$ Mat ches end of line.
. Mat ches any single charact er except newline. Using m opt ion allows it t o
mat ch newline as well.
[...] Mat ches any single charact er in bracket s.
[^...] Mat ches any single charact er not in bracket s
\A Beginning of ent ire st ring
\z End of ent ire st ring
\Z End of ent ire st ring except allowable final line t erminat or.
re* Mat ches 0 or more occurrences of preceding expression.
re+ Mat ches 1 or more of t he previous t hing
re? Mat ches 0 or 1 occurrence of preceding expression.
re{ n} Mat ches exact ly n number of occurrences of preceding expression.
re{ n,} Mat ches n or more occurrences of preceding expression.
re{ n, m} Mat ches at least n and at most m occurrences of preceding expression.
a| b Mat ches eit her a or b.
(re) Groups regular expressions and remembers mat ched t ext .
(?: re) Groups regular expressions wit hout remembering mat ched t ext .
(?> re) Mat ches independent pat t ern wit hout backt racking.
\w Mat ches word charact ers.
\W Mat ches nonword charact ers.
\s Mat ches whit espace. Equivalent t o [\t \n\r\f].
\S Mat ches nonwhit espace.
\d Mat ches digit s. Equivalent t o [0-9].
\D Mat ches nondigit s.
\A Mat ches beginning of st ring.
\Z Mat ches end of st ring. If a newline exist s, it mat ches just before newline.
\z Mat ches end of st ring.
\G Mat ches point where last mat ch finished.
\n Back-reference t o capt ure group number "n"
\b Mat ches word boundaries when out side bracket s. Mat ches backspace (0x08)
when inside bracket s.
\B Mat ches nonword boundaries.
\n, \t , et c. Mat ches newlines, carriage ret urns, t abs, et c.
\Q Escape (quot e) all charact ers up t o \E
\E Ends quot ing begun wit h \Q
Met hods of t he Mat cher Class:
Here is a list of useful inst ance met hods:
Index Met hods:
Index met hods provide useful index values t hat show precisely where t he mat ch was found in t he
input st ring:
SN Metho ds with Descriptio n
1 public int start()
Ret urns t he st art index of t he previous mat ch.
2 public int start(int gro up)
Ret urns t he st art index of t he subsequence capt ured by t he given group during t he previous
mat ch operat ion.
3 public int end()
Ret urns t he offset aft er t he last charact er mat ched.
4 public int end(int gro up)
Ret urns t he offset aft er t he last charact er of t he subsequence capt ured by t he given group
during t he previous mat ch operat ion.
St udy Met hods:
St udy met hods review t he input st ring and ret urn a Boolean indicat ing whet her or not t he pat t ern is
found:
SN Metho ds with Descriptio n
1 public bo o lean lo o kingAt()
At t empt s t o mat ch t he input sequence, st art ing at t he beginning of t he region, against t he
pat t ern.
2 public bo o lean find()
At t empt s t o find t he next subsequence of t he input sequence t hat mat ches t he pat t ern.
3 public bo o lean find(int start
Reset s t his mat cher and t hen at t empt s t o find t he next subsequence of t he input
sequence t hat mat ches t he pat t ern, st art ing at t he specified index.
4 public bo o lean matches()
At t empt s t o mat ch t he ent ire region against t he pat t ern.
Replacement Met hods:
Replacement met hods are useful met hods for replacing t ext in an input st ring:
SN Metho ds with Descriptio n
1 public Matcher appendReplacement(StringBuffer sb, String replacement)
Implement s a non-t erminal append-and-replace st ep.
2 public StringBuffer appendT ail(StringBuffer sb)
Implement s a t erminal append-and-replace st ep.
3 public String replaceAll(String replacement)
Replaces every subsequence of t he input sequence t hat mat ches t he pat t ern wit h t he
given replacement st ring.
4 public String replaceFirst(String replacement)
Replaces t he first subsequence of t he input sequence t hat mat ches t he pat t ern wit h t he
given replacement st ring.
5 public static String quo teReplacement(String s)
Ret urns a lit eral replacement St ring for t he specified St ring. This met hod produces a St ring
t hat will work as a lit eral replacement s in t he appendReplacement met hod of t he Mat cher
class.
The start and end Met hods:
Following is t he example t hat count s t he number of t imes t he word "cat s" appears in t he input
st ring:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "\\bcat\\b";
private static final String INPUT =
"cat cat cat cattie cat";
public static void main( String args[] ){
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // get a matcher object
int count = 0;
while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}
This would produce t he following result :
Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22
You can see t hat t his example uses word boundaries t o ensure t hat t he let t ers "c" "a" "t " are not
merely a subst ring in a longer word. It also gives some useful informat ion about where in t he input
st ring t he mat ch has occurred.
The st art met hod ret urns t he st art index of t he subsequence capt ured by t he given group during
t he previous mat ch operat ion, and end ret urns t he index of t he last charact er mat ched, plus one.
The matches and lookingAt Met hods:
The mat ches and lookingAt met hods bot h at t empt t o mat ch an input sequence against a pat t ern.
The difference, however, is t hat mat ches requires t he ent ire input sequence t o be mat ched, while
lookingAt does not .
Bot h met hods always st art at t he beginning of t he input st ring. Here is t he example explaining t he
funct ionalit y:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;
public static void main( String args[] ){
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);
System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}
This would produce t he following result :
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false
The replaceFirst and replaceAll Met hods:
The replaceFirst and replaceAll met hods replace t ext t hat mat ches a given regular expression. As
t heir names indicat e, replaceFirst replaces t he first occurrence, and replaceAll replaces all
occurrences.
Here is t he example explaining t he funct ionalit y:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " +
"All dogs say meow.";
private static String REPLACE = "cat";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}
This would produce t he following result :
The cat says meow. All cats say meow.
The appendReplacement and appendTail Met hods:
The Mat cher class also provides appendReplacement and appendTail met hods for t ext replacement .
Here is t he example explaining t he funct ionalit y:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
This would produce t he following result :
-foo-foo-foo-
Pat t ernSynt axExcept ion Class Met hods:
A Pat t ernSynt axExcept ion is an unchecked except ion t hat indicat es a synt ax error in a regular
expression pat t ern. The Pat t ernSynt axExcept ion class provides t he following met hods t o help you
det ermine what went wrong:
SN Metho ds with Descriptio n
1 public String getDescriptio n()
Ret rieves t he descript ion of t he error.
2 public int getIndex()
Ret rieves t he error index.
3 public String getPattern()
Ret rieves t he erroneous regular expression pat t ern.
4 public String getMessage()
Ret urns a mult i-line st ring cont aining t he descript ion of t he synt ax error and it s index, t he
erroneous regular expression pat t ern, and a visual indicat ion of t he error index wit hin t he
pat t ern.
