Scribd
Upload
49 views10 pages

Java - Regex - Original

The document provides an overview of Regular Expressions (Regex), including its definition, applications, and syntax in Java. It explains the usage of various Regex patterns and classes such as Pattern and Matcher, along with examples for matching specific character sequences, validating inputs, and extracting data. Additionally, it covers quantifiers, predefined character classes, and practical examples for validating mobile numbers and email addresses.

Uploaded by

rajeshwariraji8507
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
49 views10 pages

Java - Regex - Original

The document provides an overview of Regular Expressions (Regex), including its definition, applications, and syntax in Java. It explains the usage of various Regex patterns and classes such as Pattern and Matcher, along with examples for matching specific character sequences, validating inputs, and extracting data. Additionally, it covers quantifiers, predefined character classes, and practical examples for validating mobile numbers and email addresses.

Uploaded by

rajeshwariraji8507
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 10

Regex:

* pattern matching (from Perl)


* Regular Expression (Regex) is a sequence of characters that defines a search
pattern

eg:

Sentence : kundhavai looks gorgeous in ponniyin selvan

Find : selvan

* Application:
--------------
Chatbot
Compiler syntax checking
Validating input (e.g., email, phone numbers).
Extracting data from text.
Search and replace operations.
Text processing.
In java:
-------
import java.util.regex - API/Package

Regex class contains 3 methods:


1) Pattern - which pattern you want i.e compiled representation (Java
understandable form)
- pattern class constructor is private so we cannot create object
- So we can pass pattern inside compile method
- i.e Pattern p=new Pattern.compile("Happy");

2) Matcher - checks pattern in the sentence


3) PatternSyntaxException - handles pattern exception i.e if Uppercase missed in
pswd.

Eg:

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java.. come lets start Regex";
//Pattern p=new Pattern() - creates error bcz pattern class
constructors are private
Pattern p=Pattern.compile("come");//prepare compiled representation
Matcher m=p.matcher(sentence);
// System.out.println(p);
// System.out.println(m);
while(m.find())
{-
//System.out.println(m);
System.out.println(m.group()+m.start()+" "+m.end());
}
}
}

Character class:
----------------
To find start,end,letter in sentence etc.

Basic Regex Syntax:


------------------

eg: . => a* alc acb a*vb

-------------------------------.------------------------------------------
Pattern | Description | Example |
-------------------------------------------------------------------------
. | Any character | a.c matches abc >
* | 0 or more repetitions | ab* matches a, abb |
+ | 1 or more repetitions | ab+ matches ab, abb |
? | 0 or 1 occurrence | ab? matches a, ab |
[abc] | Any of a, b, or c | [a-c] matches a, b, c |
^ | Starts with | ^abc matches abc only |
$ | Ends with | xyz$ matches abcxyz |
-------------------------------------------------------------------------

To find start:
--------------

use ^ symbol in the pattern


eg: ^SKCET

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java.. come lets start Regex";
Pattern p=Pattern.compile("^Welcome");// to find start
Matcher m=p.matcher(sentence);
while(m.find())
{

System.out.println(m.group());
}
}
}

To find end:
------------

use $ in the pattern.

eg: SKCET$

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java.. come lets start Regex";
Pattern p=Pattern.compile("Regex$");// to find start
Matcher m=p.matcher(sentence);
while(m.find())
{
System.out.println(m.group());
}
}
}

To find two char:


-----------------
Use | inbetween char

Eg: S|K

Eg:

import java.util.regex.*;
public class Main
{
public static void main(String []n)
{
String sentence="Welcome to Java.. come c&m lets start Regex";
Pattern p=Pattern.compile("a|e|i|o|u");// to find start
Matcher m=p.matcher(sentence);
while(m.find())
{
System.out.println(m.group()+" "+m.start()+" "+m.end());
}
}
}

To find any char is present:


----------------------------

Use [] in the pattern

Eg: [SKCET] // Either S,K,C,E,T

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java.. come lets start Regex";
Pattern p=Pattern.compile("[WIR]");// to find start
Matcher m=p.matcher(sentence);
while(m.find())
{

System.out.println(m.group());
}
}
}

To find char which is not present in the pattern:


-------------------------------------------------
Use [^] in the pattern

Eg: [^SKCET] // Except S,K,C,E,T

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java.. come lets start Regex";
Pattern p=Pattern.compile("[^WIR]");// to find start
Matcher m=p.matcher(sentence);
while(m.find())
{
System.out.println(m.group());
}
}
}

[abc]---->Either a or b or c

[^abc]--->Except a, b ,c

[a-z]----->Any lower case alphabe symbol

[A-Z]---->Any Uppercse Symbol

[0-9]-->any digit from 0 to 9

[a-z A-Z]-->any aplphabet symbol

[a-z A-Z 0-9]--->any aplphanumeric symbols

[^a-z A-Z 0-9]---->Except aplha numeric i.e prints special symbols

Predefined characters classes:


------------------------------

Space & Non-Space:


------------------
1) \\s - space
2) \\S - Uppercase S for Non space character

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java";
Pattern p=Pattern.compile("\\s");
Matcher m=p.matcher(sentence);
while(m.find())
{
System.out.println(m.group()+" "+m.start()+" "+m.end());
}
}
}

Digits:
-------
//d - digit
//D - non digit
import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java@123";
Pattern p=Pattern.compile("\\d");
Matcher m=p.matcher(sentence);
while(m.find())
{
System.out.println(m.group()+" "+m.start()+" "+m.end());
}
}
}

Digits & Characters:


--------------------
//w - to find number and char
//W - to special char
import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Welcome to Java@123";
Pattern p=Pattern.compile("\\w");
Matcher m=p.matcher(sentence);
while(m.find())
{
System.out.println(m.group()+" "+m.start()+" "+m.end());
}
}
}

Quantifiers:
============

Expression Description
x? -> x occurs once or not at all i.e 0 or 1 time. eg: Pattern: a?, String:
"abc"
X* -> X occurs zero or more times Eg: Pattern: a*, String: "aaabc"
X+ -> X occurs one or more times Eg: Pattern: a+, String: "aaabc"
X{n} -> X occurs exactly n times Eg: a{2}, String: "aabc"
X{n,} -> X occurs n or more times Eg: Pattern: a{2,}, String: "aaabc"
X{n,m} -> X occurs at least n times but not more than m times Eg: Pattern:
a{2,3}, String: "aaabc"

Eg:

import java.util.regex.*;
public class Main
{
public static void main(String []n)
{
String sentence="a";
if(Pattern.matches("ab*",sentence))
{
System.out.println("Match found");
}
else {
System.out.println("Match not found");
}
}
}
Output: Match found

-------------------------------------------------------------

import java.util.regex.*;
public class Main
{
public static void main(String []n)
{
String sentence="a";
if(Pattern.matches("ab+",sentence))
{
System.out.println("Match found");
}
else {
System.out.println("Match not found");
}
}
}
Output: Match not found

eg:

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="aaaaaaabbbbbbbb";
if(Pattern.matches("a*b*",sentence))
{
System.out.println("Match found");
}
else {
System.out.println("Match not found");
}
}
}

Eg:

import java.util.regex.*;
public class Main
{
public static void main(String []n)
{
String sentence="cdefghijkl";
if(Pattern.matches("a*b*.*",sentence))
{
System.out.println("Match found");
}
else {
System.out.println("Match not found");
}
}
}

Eg: Write regex to find the name ends with Karikalan.

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="Aditya Karikalan";
if(Pattern.matches("[a-zA-Z]{1,}[\\s]Karikalan",sentence))
{
System.out.println("Match found");
}
else {
System.out.println("Match not found");
}
}
}

Write regex to find the mobile number has tendigits.


import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="9876543210";
if(Pattern.matches("[0-9]{10}",sentence))
{
System.out.println("Match found");
}
else {
System.out.println("Match not found");
}
}
}

Eg: Write regex to find the Tamilnadu mobile number or not


(MN: should starts with 6,7,8,9 )

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="6976543219";
if(Pattern.matches("[6-9]{1}[0-9]{9}",sentence))
{
System.out.println("Tamilnadu Mobile number");
}
else {
System.out.println("Outside Tamilnadu mobile number");
}
}
}
Write regex for valid mobile number.
1) should have 10 digits eg: 9087654321(or)
2) It can have 11 digits but shld starts with 0 Eg: 09087654321 (or)
3) It can have 12 digits but shld starts with 91 Eg: 91-9087654321 (or)

Solution: (0|91-)?[0-9]{10}

Valid mail ID:

import java.util.regex.*;
class main
{
public static void main(String []n)
{
String sentence="[email protected]";
if(Pattern.matches("^[\\w.]+@gmail\\.com$",sentence))
{
System.out.println("Match found");
}
else {
System.out.println("Match not found");
}
}
}

You might also like