Regular Expressions in Java

Dr. Mohamed Y. Dahab

King Adulaziz University, 2015
Regular expression (also known by pattern matching) is one of the most powerful tools available to
programmers for most of modern programming languages. This report targets students who have
some experiences in Java programming language. In addition, it can be used in Java
programming advanced course.
In this report, we shall answer the following questions:
 What is the regular expressions?
 Why using regular expressions?
 How to use regular expressions in Java?

What Is The Regular Expressions?

A regular expression is a pattern for identifying a range of string values. It can be considered as a
metalanguage to describe textual data. This metalanguage is constructed using three components
namely: character classes, quantifiers, and meta-characters. Character classes are used to define
the content of the pattern, quantifiers can be used to specify the number or length that part of a
pattern should match or repeat and meta-characters are used to group and perform special
operations in patterns. The following table shows the three components.

Character Class Description Examples

s.t matches sat, sit, sQt, s3t,
. Match a single character (except linefeed).
s&t, s t,...
Hello\tHello matches
\t Match a single tab character.
Hello     Hello.
Match a single newline (carriage return in Python) Hello\nWorld matches Hello
\n
character. World.
Web\s\spage matches
\s Match a single whitespace character.
Web          Page, Web       page
\S\S\S matches AAA, The, 5-
\S Match a single non-whitespace character.
9,...
\d\d\d matches 123, 409,
\d Match a single digit character.
982,...
\D Match a single non-digit character. \D\D matches It, as, &!,...
\w Word character [0-9a-zA-Z]
\W Not a word character [^0-9a-zA-Z]
Quantifiers

1
 Match zero or one of the previous character/expression.
? (When immediately following ?, +, *, or {min,max} it colou?r matches color, colour
prevents the expression from using "greedy" evaluation.)
a+rgh! matches argh!, aargh!,
+ Match one or more of the previous character/expression.
aaargh!,...
b(an)*a matches ba, bana,
* Match zero or more of the previous character/expression.
banana, bananana,...
Match exactly number copies of the previous .o{2}n matches noon, moon,
{number}
character/expression. loon,...
Match between min and max copies (inclusive) of the kabo{2,4}m matches kaboom,
{min,max}
previous character/expression. kabooom, kaboooom.
Metacharacter
Match a single character in set (list and/or range). Most
characters that have special meanings in regular J[aio]b matches Jab, Jib, Job
[set] expressions do not have to be backslash-escaped in [A-Z][0-9]{3} matches
character sets. To match a hyphen in the set, it must Canadian postal codes.
appear last, otherwise it indicates a range of characters.
Match a single character not in set (list and/or range). Most
characters that have special meanings in regular q[^u] matches very few
[^set] expressions do not have to be backslash-escaped in English words (Iraqi? qoph?
character sets. To not match a hyphen in the set, it must qintar?).
appear last, otherwise it indicates a range of characters.
(Mi|U)nix matches Minix and
| Match either expression that it separates.
Unix
^# matches lines that begin
^ Match the start of a line.
with #.
$ Match the end of a line. ^$ matches an empty line.

Why Using Regular Expressions?

Most of applications that deal with textual data, regular expression saves time and efforts.

How to Use Regular Expressions in Java?

Before diving into programming, I advise students to train themselves using an editor that
enables regular expressions in searching or replacing processes. I suggest using notepad++
([Link]
By pressing on ctrl-F3, you can search on a text file. Change the mode of search to use regular
expression as show in the following figure.

2
Two important methods should be considered in Java regular expressions. First, split() method.

public static void main(String[] args) {

String s1 = "Mohamed Ali Klay";
String Arr[]= [Link](" ");
for(String s: Arr)
[Link](s);
}

This code simply splits the input string, s1, into words. It will print Mohamed in one line
followed by Ali in the next line and so on. The delimiter is a regular expression, a single space.
What if the delimiter was tab or single space? Such as the following code
String s1 = "Mohamed Ali Klay";
In this case, you have to use regular expression instead. As the following code
String Arr[]= [Link]("\\s");
The first back slash for java to avoid syntax error while \s means white space.

3
 String Arr[]= [Link](" ");
The second method is matches ().
Suppose you want to ensure that a given string contains a substring, like in previous example we
want to ensure that s1contains the word Ali. See the following code:
public static void main(String[] args) {
// TODO code application logic here
String s1 = "Mohamed Ali Klay";
Boolean b = [Link](".*Ali.*");
[Link](b);
}

What if the name Ali may be written in different forms such as Ali or Aly. Here, how to solve
this problem:
public static void main(String[] args) {
// TODO code application logic here
String s1 = "Mohamed Ali Klay";
Boolean b = [Link](".*Al[iy].*");
[Link](b);
}

Another important library found in [Link], I will show hot to use this library in next
report.

Examples of Regular Expressions

What are the possible strings that matched with the following expression 1(11)*
1
111

4
 11111
Any odd numbers of ones
What about even number of ones? Can you write the regular expression?
(11)+
I use + to ensure at least one time of occurrence.

What are four possible strings that matched with the following expression 11[01]{6}
11001100
11110011
11010101
11101010

What are four possible strings that matched with the following expression 10+
100
100000
1000
1000000000
What are four possible strings that matched with the following expression (10)+
10
1010101010
101010
10101010
What are four possible strings that matched with the following expression [10]+
10
1010101010
001010
000

5
Write a regular expression that accept octal numbers of up to 4 digits, starting with a zero digit.
(for example, accept the following numbers 0256, 0755, 0232, 0110)

0[0-7]{1,3}

Write a regular expression that accept five hexa-decimal numbers (for example, accept the
following numbers af121, dd5d2, 02010, 885cb)

[0-9a-fA-F]{5}

What are four possible strings that matched with the following expression \d+[abc]\s?;
585a;
5 a;
125b;
58523123b ;

References
Alfred, V. "Algorithms for Finding Patterns in Strings." Algorithms and Complexity (2014): 255.