• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Java Regular Expression PART I
 

Java Regular Expression PART I

on

  • 875 views

Regular Expressions (Regex) is powerful and convenient to use for string manipulation i.e. matching and validation, extracting and capturing, modifying and substitution, etc. This presentation covers ...

Regular Expressions (Regex) is powerful and convenient to use for string manipulation i.e. matching and validation, extracting and capturing, modifying and substitution, etc. This presentation covers Regular Expression with real world examples and demos.
All in all, Regular Expression is worth learning!!!

Statistics

Views

Total Views
875
Views on SlideShare
875
Embed Views
0

Actions

Likes
5
Downloads
32
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Java Regular Expression PART I Java Regular Expression PART I Presentation Transcript

    • » 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 https://www.facebook.com/Oxus20 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 https://www.facebook.com/Oxus20
    • 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 https://www.facebook.com/Oxus20
    • 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 https://www.facebook.com/Oxus20
    • 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. https://www.facebook.com/Oxus20 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. https://www.facebook.com/Oxus20 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 https://www.facebook.com/Oxus20
    • 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. https://www.facebook.com/Oxus20 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 https://www.facebook.com/Oxus20
    • Example II Demo (Alternative) public class RegexBasicExampleII { public static void main(String[] args) { 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 https://www.facebook.com/Oxus20
    • 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 https://www.facebook.com/Oxus20
    • Example III Demo public class RegexBasicExampleIII { 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+")); // true } } 13 https://www.facebook.com/Oxus20
    • 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" https://www.facebook.com/Oxus20 14
    • Example IV Demo public class RegexBasicExampleIV { public static void main(String[] args) { 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 https://www.facebook.com/Oxus20
    • 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 https://www.facebook.com/Oxus20
    • 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 https://www.facebook.com/Oxus20
    • Basic Grouping Demo I (Case Sensitive) public class BasicGroupingDemoI { public static void main(String[] args) { 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 https://www.facebook.com/Oxus20
    • Basic Grouping Demo I (Case Insensitive) public class BasicGroupingDemoI { public static void main(String[] args) { 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 https://www.facebook.com/Oxus20
    • 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 https://www.facebook.com/Oxus20
    • SSN Match and Validation public class SSNMatchAndValidate { public static void main(String[] args) { 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 https://www.facebook.com/Oxus20 { 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 -? optionally match a dash d{4} match only 4 digits $ match the end of the line https://www.facebook.com/Oxus20 22
    • SSN Match and Validation (Alternative) public class SSNMatchAndValidateII { public static void main(String[] args) { 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 https://www.facebook.com/Oxus20 { 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 -? optionally match a dash [0-9]{2} match only 2 digits -? optionally match a dash [0-9]{4} match only 4 digits $ match the end of the line https://www.facebook.com/Oxus20 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 https://www.facebook.com/Oxus20
    • Extracting / Capturing Numbers import java.util.regex.Matcher; import java.util.regex.Pattern; public class ExtractingNumbers { public static void main(String[] args) { 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 } } https://www.facebook.com/Oxus20 26
    • Extracting / Capturing Explanation » Import the needed classes import java.util.regex.Matcher; import java.util.regex.Pattern; » 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 Matcher m = p.matcher(text); » 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. https://www.facebook.com/Oxus20 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 https://www.facebook.com/Oxus20
    • Extract / Capture Emails import java.util.regex.Matcher; import java.util.regex.Pattern; public class ExtractEmails { public static void main(String[] args) { 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); Matcher m = p.matcher(text); while (m.find()) { System.out.println(m.group()); } } OUTPUT: absherzad@gmail.com oxus20@gmail.com } https://www.facebook.com/Oxus20 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 https://www.facebook.com/Oxus20
    • Mask Sensitive Information import java.util.regex.Matcher; import java.util.regex.Pattern; public class Substitutions { public static void main(String[] args) { String text = "Three student with StudentID=20120, StudentID=20121 and finally StudentID=20122."; Pattern p = Pattern.compile("(StudentID=)([0-9]+)"); Matcher m = p.matcher(text); 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 } https://www.facebook.com/Oxus20
    • Mask Sensitive Information (OUTPUT) » Masking: 20120 » Masking: 20121 » Masking: 20122 » Three student with StudentID=***masked***, StudentID=***masked*** and finally StudentID=***masked***. 32 https://www.facebook.com/Oxus20
    • 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 https://www.facebook.com/Oxus20
    • END 34 https://www.facebook.com/Oxus20