Java Regular Expression PART I

» String Manipulation
» Matching / Validating
» Extracting / Capturing
» Modifying / Substitution

https://www.facebook.com/Oxus20

oxus20@gmail.com

Java
Regular
Expression
PART I
Abdul Rahman Sherzad

Agenda
» What is Regular Expression
» Regular Expression Syntax
˃ Character Classes
˃ Quantifiers
˃ Meta Characters.
» Basic Expression Example
» Basic Grouping Example
» Matching / Validating
» Extracting/Capturing
» Modifying/Substitution

2

What are Regular Expressions?
» Regular Expressions are a language of string patterns built
into most modern programming languages, Perl, PHP, .NET
and including Java 1.4 onward.
» A regular expression defines a search pattern for strings.
» Regular expressions can be used to search, edit and
manipulate text.
» The abbreviation for Regular Expression is Regex.
3


Regular Expression Syntax
» Regular Expressions, by definition, are string patterns
that describe text.
» These descriptions can then be used in nearly infinite
ways.
» The basic language constructs include
˃ Character Classes
˃ Quantifiers
˃ Meta Characters.
4


Character Classes
Character
Class

Explanation and Alternatives

.

Match any character (may or may not match line terminators)

d

Matches a digit, is an alternative for:

D

Matches a non-digit character, is an alternative for:

s

Matches a whitespace character, is an alternative for:

[0-9]
[^0-9]

[ tnx0Bfr]
S

Matches a non-whitespace character, is an alternative for:

w

Match a word character, is an alternative for:

W

Match a non-word character, is an alternative for:

[^s]

[a-zA-Z_0-9]
[^w]

NOTE: in Java, you will need to "double escape" these backslashes "" i.e. "d" should be "d".
5


Quantifiers
Quantifiers Explanation and Alternatives
*

Match zero or more times, is an alternative for

+

Match one or more times, is an alternative for

{1,}

?

Match no or one times, ? is an alternative for

{0,1}

{n}

Match exactly

{n,}

Match at least

n times,

{n,m}

Match at least

n but not more than m times

{0,}

n number of times

Quantifiers can be used to specify the number or length that part of a
pattern should match or repeat.

6

Meta Characters
Meta
Characters

Explanation

Escape the next meta-character (it becomes a normal
/ literal character)
Match the beginning of the line

^
.

Match any character (except newline)

$

Match the end of the line (or before newline at the
end)
Alternation for ('or' statement)

|
()

Grouping

[]

Custom character class

Meta-characters are used to group, divide, and perform special
operations in patterns.

7

Basic Expression: Example I
» Every string is a Regular Expression.
» For example, the string, "I study English", is a regular
expression that will match exactly the string, "I study
English", and will ignore everything else.
» What if we want to be able to find more subject that

we study? We can replace the word English with a
character class expression that will match any
subject. Example on next slide …
8


Basic Expression: Example II
"I study w+"
» As you can see, the above pattern "I study w+" uses
both a character class and a quantifier.
» The character class "w" says match a word character
» The quantifier "+" says match one or more.

» Now the pattern "I study w+" will match any word in
place of "English" i.e. "I study Programming", "I study
Math", "I study Database", etc.

9

Example II Demo
public class RegexBasicExampleII {
public static void main(String[] args) {
System.out.println("I study English".matches("I study w+")); // true
System.out.println("I study Programming".matches("I study w+")); // true
System.out.println("I study JAVA".matches("I study w+")); // true
System.out.println("I study: JAVA".matches("I study w+")); // false

}
}
10


Example II Demo (Alternative)
public class RegexBasicExampleII {
System.out.println("I study English".matches("I study [a-zA-Z_0-9]+")); // true
System.out.println("I study Programming".matches("I study [a-zA-Z_0-9]+")); // true
System.out.println("I study JAVA".matches("I study [a-zA-Z_0-9]+")); // true
System.out.println("I study: JAVA".matches("I study [a-zA-Z_0-9]+")); // false

}
}
11


Basic Expression: Example III
» But the pattern "I study w+" will not match "I study:
English", because as soon as the expression finds the ":"
character, which is not a word character, it will stop
matching.
» If we want the expression to be able to handle this
situation, then we need to make a small change as follow:

» "I study:? w+"
» Now the pattern "I study:? w+" will match "I study
Programming" and also "I study: Programming"
12


Example III Demo
public class RegexBasicExampleIII {
System.out.println("I study English".matches("I study:? w+")); // true
System.out.println("I study Programming".matches("I study:? w+")); // true
System.out.println("I study JAVA".matches("I study:? w+")); // true
System.out.println("I study: JAVA".matches("I study:? w+")); // true

}
}
13


Basic Expression: Example IV
» Also the pattern "I study w+" will not match neither the
string "i study English" and nor "I Study English" , because as
soon as the expression finds the lowercase "i", which is not
equal uppercase "I", it will stop matching.
» If we want the expression to be able to handle this situation
does not care about the case sensitivity then we need to make a

small change as follow:
» "(?i)I study w+"
» Now the pattern "(?i)I study w+" will match both "I STUDY
JAVA" and also "i StUdY JAVA"

14

Example IV Demo
public class RegexBasicExampleIV {
System.out.println("I study English".matches("(?i)I study w+")); // true
System.out.println("i STUDY English".matches("(?i)I study w+")); // true
System.out.println("I study JAVA".matches("(?i)I study w+")); // true
System.out.println("i StUdY JAVA".matches("(?i)I study w+")); // true

}
}
15


Regular Expression Basic Grouping
» An important feature of Regular Expressions is the
ability to group sections of a pattern, and provide
alternate matches.
» The following two meta-characters are core parts of
flexible Regular Expressions
˃ | Alternation ('or' statement)
˃ () Grouping
» Consider if we know exactly subjects we are studying, and we
want to find only those subjects but nothing else. Following is
the pattern:
» "I study (Java|English|Programming|Math|Islamic|HTML)"
16


Regular Expression Basic Grouping
» "I study (Java|English|Programming|Math|Islamic|HTML)"
» The new expression will now match the beginning of the string "I
study", and then any one of the subjects in the group, separated by
alternators, "|"; any one of the following would be a match:
˃ Java
˃ English
˃ Programming
˃ Math
˃ Islamic
˃ HTML
17


Basic Grouping Demo I (Case Sensitive)
public class BasicGroupingDemoI {

String pattern = "I study (Java|English|Programming|Math|Islamic|HTML)";
System.out.println("I study English".matches(pattern)); // true
System.out.println("I study Programming".matches(pattern)); // true
System.out.println("I study Islamic".matches(pattern)); // true

// english with lowercase letter "e" is not in our group
System.out.println("I study english".matches(pattern)); // false
// CSS is not in our group
System.out.println("I study CSS".matches(pattern)); // false
}
}

18


Basic Grouping Demo I (Case Insensitive)
public class BasicGroupingDemoI {

String pattern = "(?i)I study (Java|English|Programming|Math|Islamic|HTML)";
System.out.println("I study English".matches(pattern)); // true
System.out.println("I study Programming".matches(pattern)); // true
System.out.println("I study Islamic".matches(pattern)); // true
System.out.println("I study english".matches(pattern)); // true

// CSS is not in our group
System.out.println("I study CSS".matches(pattern)); // false
}
}
19


Matching / Validating
» Regular Expressions make it possible to find all instances of
text that match a certain pattern, and return a Boolean
value if the pattern is found / not found.
» This can be used to validate user input such as
˃
˃
˃
˃
˃

Phone Numbers
Social Security Numbers (SSN)
Email Addresses
Web Form Input Data
and much more.

» Consider the purpose is to validate the SSN if the pattern is
found in a String, and the pattern matches a SSN, then the
string is an SSN.
20


SSN Match and Validation
public class SSNMatchAndValidate {
String pattern = "^(d{3}-?d{2}-?d{4})$";
String input[] = new String[5];
input[0]
input[1]
input[2]
input[3]
input[4]

=
=
=
=
=

"123-45-6789";
"9876-5-4321";
"987-650-4321";
"987-65-4321 ";
"321-54-9876";

for (int i = 0; i < input.length; i++)
if (input[i].matches(pattern)) {
System.out.println("Found correct
}
}
OUTPUT:
}
Found correct
}
Found correct

{
SSN: " + input[i]);

SSN: 123-45-6789
SSN: 321-54-9876

21

SSN Match and Validation Detail
"^(d{3}-?d{2}-?d{4})$"
Regular

// 123-45-6789

Meaning

Expression
^

match the beginning of the line

()

group everything within the parenthesis as group 1

d{3}

match only 3 digits

-?

optionally match a dash

d{2}

match only 2 digits

-?


d{4}

match only 4 digits

$

match the end of the line

22

SSN Match and Validation (Alternative)
public class SSNMatchAndValidateII {
String pattern = "^([0-9]{3}-?[0-9]{2}-?[0-9]{4})$";
String input[] = new String[5];
input[0]
input[1]
input[2]
input[3]
input[4]

=
=
=
=
=

"123-45-6789";
"9876-5-4321";
"987-650-4321";
"987-65-4321 ";
"321-54-9876";

for (int i = 0; i < input.length; i++)
if (input[i].matches(pattern)) {
System.out.println("Found correct
}
}
OUTPUT:
}
Found correct
}
Found correct

{
SSN: " + input[i]);

SSN: 123-45-6789
SSN: 321-54-9876

23

SSN Match and Validation Detail
"^([0-9]{3}-?[0-9]{2}-?[0-9]{4})$"
Regular

// 123-45-6789

Meaning

Expression
^

match the beginning of the line

()

group everything within the parenthesis as group 1

[0-9]{3}

match only 3 digits

-?


[0-9]{2}

match only 2 digits

-?


[0-9]{4}

match only 4 digits

$

match the end of the line

24

Extracting / Capturing
» Capturing groups are an extremely useful feature of
Regular Expression matching that allow us to query
the Matcher to find out what the part of the string was that
matched against a particular part of the regular expression.
» Consider you have a large complex body of text (with an

unspecified number of numbers) and you would like to
extract all the numbers.
» Next Slide demonstrate the example
25


Extracting / Capturing Numbers
import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class ExtractingNumbers {

String text = "Abdul Rahman Sherzad with university ID of 20120 is trying to
demonstrate the power of Regular Expression for OXUS20 members.";
Pattern p = Pattern.compile("d+");
Matcher m = p.matcher(text);
while (m.find()) {
System.out.println(m.group());
}

OUTPUT:
20120
20

}
}


26

Extracting / Capturing Explanation
» Import the needed classes
» First, you must compile the pattern
Pattern p = Pattern.compile("d+");
» Next, create a matcher for a target text by sending a message to your
pattern
» NOTES
˃ Neither Pattern nor Matcher has a public constructor;
+ use static Pattern.compile(String regExpr) for creating pattern
instances
+ using Pattern.matcher(String text) for creating instances of
matchers.
˃ The matcher contains information about both the pattern and the
target text.

27

Extracting / Capturing
Explanation
» m.find()
˃ returns true if the pattern matches any part of the
text string,
˃ If called again, m.find() will start searching from

where the last match was found
˃ m.find() will return true for as many matches as
there are in the string; after that, it will return false
28


Extract / Capture Emails
public class ExtractEmails {
String text = "Abdul Rahman Sherzad absherzad@gmail.com
on OXUS20 oxus20@gmail.com";
String pattern = "[A-Za-z0-9-_]+(.[A-Za-z0-9-_]+)*@[AZa-z0-9-]+(.[A-Za-z0-9]+)*(.[A-Za-z]{2,})";
Pattern p = Pattern.compile(pattern);
while (m.find()) {
System.out.println(m.group());
}
}

OUTPUT:
absherzad@gmail.com
oxus20@gmail.com

}

29

Modifying / Substitution
» Values in String can be replaced with new values
» For example, you could replace all instances of the
word 'StudentID=', followed by an ID, with a mask to
hide the original ID.
» This can be a useful method of filtering sensitive
information.
» Next Slide demonstrate the example
30


Mask Sensitive Information
public class Substitutions {
String text = "Three student with StudentID=20120, StudentID=20121 and
finally StudentID=20122.";
Pattern p = Pattern.compile("(StudentID=)([0-9]+)");
StringBuffer result = new StringBuffer();
while (m.find()) {
System.out.println("Masking: " + m.group(2));
m.appendReplacement(result, m.group(1) + "***masked***");
}
m.appendTail(result);
System.out.println(result);
}

31

}

Mask Sensitive Information
(OUTPUT)
» Masking: 20120
» Masking: 20121
» Masking: 20122
» Three student with StudentID=***masked***,
StudentID=***masked*** and finally
StudentID=***masked***.
32


Conclusion
» Regular Expressions are not easy to use at first
˃ It is a bunch of punctuation, not words
˃ It takes practice to learn to put them together correctly.

» Regular Expressions form a sub-language
˃ It has a different syntax than Java.
˃ It requires new thought patterns
˃ Can't use Regular Expressions directly in java; you have to create Patterns
and Matchers first or use the matches method of String class.

» Regular Expressions is powerful and convenient
to use for string manipulation
˃ It is worth learning!!!
33


END

34


Java Regular Expression PART I

Recommandé

Recommandé

Contenu connexe

Similaire à Java Regular Expression PART I

Similaire à Java Regular Expression PART I (20)

Plus de Abdul Rahman Sherzad

Plus de Abdul Rahman Sherzad (20)

Dernier

Dernier (20)

Java Regular Expression PART I