Java Regular Expressions (Regex)

Last Updated : 12 Jan 2026

The Java Regex or Regular Expression is an API used to define patterns for searching or manipulating strings.

It is widely used to define constraints on strings, such as password and email validation. After learning the Java Regex, you will be able to test your regular expressions using the Java Regex Tester tool.

The Java Regex API provides one interface and three classes in the java.util.regex package

java.util.regex package

The Matcher and Pattern classes provide the facility of Java regular expression. The java.util.regex package provides following classes and interfaces for regular expressions.

MatchResult interface
Matcher class
Pattern class
PatternSyntaxException class

Matcher class

It implements the MatchResult interface. It is a regex engine which is used to perform match operations on a character sequence.

No.	Method	Description
1	boolean matches()	test whether the regular expression matches the pattern.
2	boolean find()	finds the next expression that matches the pattern.
3	boolean find(int start)	finds the next expression that matches the pattern from the given start number.
4	String group()	returns the matched subsequence.
5	int start()	returns the starting index of the matched subsequence.
6	int end()	returns the ending index of the matched subsequence.
7	int groupCount()	returns the total number of the matched subsequence.

Pattern class

It is the compiled version of a regular expression. It is used to define a pattern for the regex engine.

No.	Method	Description
1	static Pattern compile(String regex)	compiles the given regex and returns the instance of the Pattern.
2	Matcher matcher(CharSequence input)	creates a matcher that matches the given input with the pattern.
3	static boolean matches(String regex, CharSequence input)	It works as the combination of compile and matcher methods. It compiles the regular expression and matches the given input with the pattern.
4	String[] split(CharSequence input)	splits the given input string around matches of given pattern.
5	String pattern()	returns the regex pattern.

Example of Java Regular Expressions

There are three ways to write the regex example in Java.

Example

//Creating an example to understand the use of Java Regular Expression
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main{  
public static void main(String args[]){  
//1st way  
Pattern p = Pattern.compile(".s");//. represents single character  
Matcher m = p.matcher("as");  
boolean b = m.matches();  
  
//2nd way  
boolean b2=Pattern.compile(".s").matcher("as").matches();  
  
//3rd way  
boolean b3 = Pattern.matches(".s", "as");  
  
System.out.println(b+" "+b2+" "+b3);  
}}  

Compile and Run

Output

true true true

Dot (.) Quantifier in Java Regex

In Java regular expressions, the dot (.) quantifier matches exactly one character, except a newline. It is commonly used when the exact character is not known but its position in the string matters.

Example

Consider the following example to understand the use of the dot (.) quantifier in Java regex.

//Java Program to understand the use of dot . quantifier
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println(Pattern.matches(".s", "as"));//true (2nd char is s)  
System.out.println(Pattern.matches(".s", "mk"));//false (2nd char is not s)  
System.out.println(Pattern.matches(".s", "mst"));//false (has more than 2 char)  
System.out.println(Pattern.matches(".s", "amms"));//false (has more than 2 char)  
System.out.println(Pattern.matches("..s", "mas"));//true (3rd char is s)  
}}

Compile and Run

Java Regex Character Classes

Java Regex character classes are used to define a set or group of characters that can match a single character at a specific position in a string.

The following table shows different types of character classes in Java Regular Expressions and explains how each character class pattern is used to match specific sets or ranges of characters while performing pattern matching.

No.	Character Class	Description
1	[abc]	a, b, or c (simple class)
2	[^abc]	Any character except a, b, or c (negation)
3	[a-zA-Z]	a through z or A through Z, inclusive (range)
4	[a-d[m-p]]	a through d, or m through p: [a-dm-p] (union)
5	[a-z&&[def]]	d, e, or f (intersection)
6	[a-z&&[^bc]]	a through z, except for b and c: [ad-z] (subtraction)
7	[a-z&&[^m-p]]	a through z, and not m through p: [a-lq-z](subtraction)

Example

Consider the following example to understand the use of character classes in regular expressions:

//Java Program to understand the use of Regex Character class
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println(Pattern.matches("[amn]", "abcd"));//false (not a or m or n)  
System.out.println(Pattern.matches("[amn]", "a"));//true (among a or m or n)  
System.out.println(Pattern.matches("[amn]", "ammmna"));//false (m and a comes more than once)  
}} 

Compile and Run

Java Regex Quantifiers

Java Regex Quantifiers define how many times a character, group, or character class can occur in a pattern. They are used to control the repetition of elements while matching strings.

The following table shows different types of quantifiers in Java Regular Expressions and explains how each quantifier controls the number of times a character or pattern can occur in a string.

Regex	Description
X?	X occurs once or not at all
X+	X occurs once or more times
X*	X occurs zero or more times
X{n}	X occurs n times only
X{n,}	X occurs n or more times
X{y,z}	X occurs at least y times but less than z times

Example

The following example demonstrates how different regex quantifiers (?, +, *) work with the character class [amn].

[amn]? (zero or one occurrence):
The string can contain only one character from a, m, or n, or none at all. Any string with more than one character or repeated occurrences does not match.
[amn]+ (one or more occurrences):
The string must contain at least one character from a, m, or n, and it can repeat multiple times. If any other character appears, the match fails.
[amn]* (zero or more occurrences):
The string may contain any number of characters from a, m, or n, including zero occurrences. As long as no other characters are present, the match succeeds.

//Java Program to understand the use of regex quantifiers
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println("? quantifier ....");  
System.out.println(Pattern.matches("[amn]?", "a"));//true (a or m or n comes one time)  
System.out.println(Pattern.matches("[amn]?", "aaa"));//false (a comes more than one time)  
System.out.println(Pattern.matches("[amn]?", "aammmnn"));//false (a m and n comes more than one time)  
System.out.println(Pattern.matches("[amn]?", "aazzta"));//false (a comes more than one time)  
System.out.println(Pattern.matches("[amn]?", "am"));//false (a or m or n must come one time)  
  
System.out.println("+ quantifier ....");  
System.out.println(Pattern.matches("[amn]+", "a"));//true (a or m or n once or more times)  
System.out.println(Pattern.matches("[amn]+", "aaa"));//true (a comes more than one time)  
System.out.println(Pattern.matches("[amn]+", "aammmnn"));//true (a or m or n comes more than once)  
System.out.println(Pattern.matches("[amn]+", "aazzta"));//false (z and t are not matching pattern)  
  
System.out.println("* quantifier ....");  
System.out.println(Pattern.matches("[amn]*", "ammmna"));//true (a or m or n may come zero or more times)  
  
}}  

Compile and Run

Java Regex Metacharacters

Java Regex Metacharacters are special characters that have a predefined meaning in regular expressions and are used to define rules for pattern matching, such as position, repetition, or character types.

This table shows commonly used metacharacters in Java Regular Expressions along with their meanings, explaining how each metacharacter is used to match specific character types, positions, or boundaries in a string.

Regex	Description
.	Any character (may or may not match terminator)
\d	Any digits, short of [0-9]
\D	Any non-digit, short for [^0-9]
\s	Any whitespace character, short for [\t\n\x0B\f\r]
\S	Any non-whitespace character, short for [^\s]
\w	Any word character, short for [a-zA-Z_0-9]
\W	Any non-word character, short for [^\w]
\b	A word boundary
\B	A non word boundary

Example

The following example demonstrates the use of regex metacharacters \d and \D:.

\d (digit):
It matches exactly one digit from 0 to 9. If the input contains non-digit characters or more than one character, the match fails.
\D (non-digit):
It matches exactly one non-digit character. If digits are present or the string has more than one character, the match does not succeed.
\D* (non-digit with quantifier):
The * quantifier allows zero or more non-digit characters, so strings containing only non-digits of any length are matched successfully.

//Java Program to understand the use of Regex Metacharacters
import java.util.regex.Pattern;  
public class Main{  
public static void main(String args[]){  
System.out.println("metacharacters d....");//d means digit  
  
System.out.println(Pattern.matches("\\d", "abc"));//false (non-digit)  
System.out.println(Pattern.matches("\\d", "1"));//true (digit and comes once)  
System.out.println(Pattern.matches("\\d", "4443"));//false (digit but comes more than once)  
System.out.println(Pattern.matches("\\d", "323abc"));//false (digit and char)  
  
System.out.println("metacharacters D....");//D means non-digit  
  
System.out.println(Pattern.matches("\\D", "abc"));//false (non-digit but comes more than once)  
System.out.println(Pattern.matches("\\D", "1"));//false (digit)  
System.out.println(Pattern.matches("\\D", "4443"));//false (digit)  
System.out.println(Pattern.matches("\\D", "323abc"));//false (digit and char)  
System.out.println(Pattern.matches("\\D", "m"));//true (non-digit and comes once)  
  
System.out.println("metacharacters D with quantifier....");  
System.out.println(Pattern.matches("\\D*", "mak"));//true (non-digit and may come 0 or more times)  
  
}}  

More Examples on Java Regex

Practice the following examples to strengthen your understanding of Java Regular Expressions. These examples cover pattern matching, validation, searching, replacing, and extracting information using regex.

Example 1: Alphanumeric String Validation (Fixed Length)

import java.util.regex.*;
class RegexExample6{
public static void main(String args[]){
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "arun32"));//true
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "kkvarun32"));//false (more than 6 char)
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "JA2Uk2"));//true
System.out.println(Pattern.matches("[a-zA-Z0-9]{6}", "arun$2"));//false ($ is not matched)
}}

Example 2: Mobile Number Validation Using Regex

The following example demonstrates how to validate 10-digit numeric mobile numbers that must start with 7, 8, or 9, using character classes, quantifiers, and metacharacters.

/*Create a regular expression that accepts 10 digit numeric characters
 starting with 7, 8 or 9 only.*/

import java.util.regex.*;
class RegexExample7{
public static void main(String args[]){
System.out.println("by character classes and quantifiers ...");
System.out.println(Pattern.matches("[789]{1}[0-9]{9}", "9953038949"));//true
System.out.println(Pattern.matches("[789][0-9]{9}", "9953038949"));//true

System.out.println(Pattern.matches("[789][0-9]{9}", "99530389490"));//false (11 characters)
System.out.println(Pattern.matches("[789][0-9]{9}", "6953038949"));//false (starts from 6)
System.out.println(Pattern.matches("[789][0-9]{9}", "8853038949"));//true

System.out.println("by metacharacters ...");
System.out.println(Pattern.matches("[789]{1}\\d{9}", "8853038949"));//true
System.out.println(Pattern.matches("[789]{1}\\d{9}", "3853038949"));//false (starts from 3)

}}

Example 3: Java Regex Finder Tool

The following example demonstrates how to search and locate multiple occurrences of a regex pattern within a given text using the Pattern and Matcher classes.

import java.util.regex.Pattern;
import java.util.Scanner;
import java.util.regex.Matcher;  
public class RegexExample8{  
    public static void main(String[] args){  
        Scanner sc=new Scanner(System.in);
        while (true) {  
        	System.out.println("Enter regex pattern:");
            Pattern pattern = Pattern.compile(sc.nextLine());  
            System.out.println("Enter text:");
            Matcher matcher = pattern.matcher(sc.nextLine());  
            boolean found = false;  
            while (matcher.find()) {  
                System.out.println("I found the text "+matcher.group()+" starting at index "+  
                 matcher.start()+" and ending at index "+matcher.end());  
                found = true;  
            }  
            if(!found){  
                System.out.println("No match found.");  
            }  
        }  
    }  
}  

Output:

Enter regex pattern: java
Enter text: this is java, do you know java
I found the text java starting at index 8 and ending at index 12
I found the text java starting at index 26 and ending at index 30

Example 4: Java Regex Features Demonstration

The following example demonstrates various regex operations such as:

Matching specific patterns
Finding words using boundaries
Replacing text
Splitting strings
Validating email addresses
Extracting domain names from URLs

// Java program for demonstrating the features and functionalities of Java Regrex
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class JavaRegrex {

    public static void main(String[] args) {
        // Example 1: Matching a specific pattern
        System.out.println("Example 1: Matching a specific pattern");
        // Define the text in which to search
        String text1 = "The quick brown fox jumps over the lazy dog";
        // Define the pattern to match
        String pattern1 = "fox";
        // Check if the pattern matches the text using Pattern.matches()
        boolean matches1 = Pattern.matches(pattern1, text1);
        // Output whether the text contains the pattern
        System.out.println("Does the text contain the word 'fox'? " + matches1);

        // Example 2: Using Pattern and Matcher classes
        System.out.println("\nExample 2: Using Pattern and Matcher classes");
        // Define the text to search within
        String text2 = "Java is a programming language";
        // Define the regex pattern to match 3-letter words
        String regex2 = "\\b\\w{3}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern pattern2 = Pattern.compile(regex2);
        // Create a Matcher object to apply the pattern on the text
        Matcher matcher2 = pattern2.matcher(text2);
        // Find and output all matches found by iterating over Matcher's results
        System.out.print("3-letter words in the text: ");
        while (matcher2.find()) {
            System.out.print(matcher2.group() + " ");
        }
        System.out.println();

        // Example 3: Replacing matched patterns
        System.out.println("\nExample 3: Replacing matched patterns");
        // Define the text in which to search
        String text3 = "The cat sat on the mat";
        // Define the regex pattern to match the word 'cat'
        String regex3 = "\\bcat\\b";
        // Define the replacement string
        String replacement3 = "dog";
        // Replace all occurrences of 'cat' with 'dog' using String's replaceAll()
        // method
        String replacedText3 = text3.replaceAll(regex3, replacement3);
        // Output the original and replaced text
        System.out.println("Original text: " + text3);
        System.out.println("Replaced text: " + replacedText3);
        // Example 4: Splitting text using regex
        System.out.println("\nExample 4: Splitting text using regex");
        // Define the text to split
        String text4 = "apple,banana,orange,grape";
        // Define the regex pattern for splitting by comma
        String regex4 = ",";
        // Split the text using the regex pattern into an array of strings
        String[] parts4 = text4.split(regex4);
        // Output the split parts
        System.out.print("Fruits separated: ");
        for (String part : parts4) {
            System.out.print(part + " ");
        }
        System.out.println();
        // Example 5: Validating email addresses
        System.out.println("\nExample 5: Validating email addresses");
        // Define an array of email addresses to validate
        String[] emails = { "user@example.com", "invalid.email.com", "another.user@domain.co" };
        // Define the regex pattern for validating email addresses
        String emailRegex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
        // Compile the regex pattern into a Pattern object
        Pattern emailPattern = Pattern.compile(emailRegex);
        // Validate each email address by matching against the regex pattern
        System.out.println("Validating email addresses:");
        for (String email : emails) {
            // Create a Matcher object for each email
            Matcher emailMatcher = emailPattern.matcher(email);
            // Output the result of validation
            System.out.println(email + ": " + emailMatcher.matches());
        }
        // Example 6: Extracting domain names from URLs
        System.out.println("\nExample 6: Extracting domain names from URLs");
        // Define a URL
        String url = "https://www.example.com";
        // Define the regex pattern for extracting domain names from URLs
        String domainRegex = "^(https?://)?(www\\.)?([a-zA-Z0-9-]+\\.[a-z]{2,})";
        // Compile the regex pattern into a Pattern object
        Pattern domainPattern = Pattern.compile(domainRegex);
        // Create a Matcher object for the URL
        Matcher domainMatcher = domainPattern.matcher(url);
        // Find the domain name by matching against the regex pattern and output it
        if (domainMatcher.find()) {
            System.out.println("Domain extracted from URL: " + domainMatcher.group(3));
        }
    }
}

Output:

Example 1: Matching a specific pattern
Does the text contain the word 'fox'? false

Example 2: Using Pattern and Matcher classes
3-letter words in the text:

Example 3: Replacing matched patterns
Original text: The cat sat on the mat
Replaced text: The dog sat on the mat

Example 4: Splitting text using regex
Fruits separated: apple banana orange grape

Example 5: Validating email addresses
Validating email addresses:
user@example.com: true
invalid.email.com: false
another.user@domain.co: true

Example 6: Extracting domain names from URLs
Domain extracted from URL: example.com

Example 5: Extracting Data Using Regex Patterns

The following example demonstrates how to extract:

Phone numbers
URLs
Email addresses
Dates

from a given text using regular expressions and the Matcher class.

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexFeatures {
    public static void main(String[] args) {
        // Example 1: Extracting phone numbers from text
        System.out.println("Example 1: Extracting phone numbers from text");
        // Define the text containing phone numbers
        String text1 = "Please call 123-456-7890 for assistance or 987-654-3210 for inquiries.";
        // Define the regex pattern to match phone numbers in the format xxx-xxx-xxxx
        String phoneRegex1 = "\\b\\d{3}-\\d{3}-\\d{4}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern phonePattern1 = Pattern.compile(phoneRegex1);
        // Create a Matcher object for the text
        Matcher phoneMatcher1 = phonePattern1.matcher(text1);
        // Find and output all matched phone numbers
        System.out.print("Phone numbers found in the text: ");
        while (phoneMatcher1.find()) {
            System.out.print(phoneMatcher1.group() + " ");
        }
        System.out.println();
        // Example 2: Extracting URLs from text
        System.out.println("\nExample 2: Extracting URLs from text");
        // Define the text containing URLs
        String text2 = "Visit our website at https://www.example.com or http://another.example.org";
        // Define the regex pattern to match URLs
        String urlRegex2 = "\\bhttps?://\\S+\\b";
        // Compile the regex pattern into a Pattern object
        Pattern urlPattern2 = Pattern.compile(urlRegex2);
        // Create a Matcher object for the text
        Matcher urlMatcher2 = urlPattern2.matcher(text2);
        // Find and output all matched URLs
        System.out.print("URLs found in the text: ");
        while (urlMatcher2.find()) {
            System.out.print(urlMatcher2.group() + " ");
        }
        System.out.println();

        // Example 3: Matching email addresses in text
        System.out.println("\nExample 3: Matching email addresses in text");
        // Define the text containing email addresses
        String text3 = "Contact us at email@example.com or another.email@example.org";
        // Define the regex pattern to match email addresses
        String emailRegex3 = "\\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern emailPattern3 = Pattern.compile(emailRegex3);
        // Create a Matcher object for the text
        Matcher emailMatcher3 = emailPattern3.matcher(text3);
        // Find and output all matched email addresses
        System.out.print("Email addresses found in the text: ");
        while (emailMatcher3.find()) {
            System.out.print(emailMatcher3.group() + " ");
        }
        System.out.println();

        // Example 4: Finding dates in text
        System.out.println("\nExample 4: Finding dates in text");
        // Define the text containing dates
        String text4 = "Important meetings on 2024-02-15 and 2024/02/20";
        // Define the regex pattern to match dates in the format yyyy-mm-dd or yyyy/mm/dd
        String dateRegex4 = "\\b\\d{4}[-/]\\d{2}[-/]\\d{2}\\b";
        // Compile the regex pattern into a Pattern object
        Pattern datePattern4 = Pattern.compile(dateRegex4);
        // Create a Matcher object for the text
        Matcher dateMatcher4 = datePattern4.matcher(text4);
        // Find and output all matched dates
        System.out.print("Dates found in the text: ");
        while (dateMatcher4.find()) {
            System.out.print(dateMatcher4.group() + " ");
        }
        System.out.println();
    }
}

Output:

Example 1: Extracting phone numbers from text
Phone numbers found in the text: 123-456-7890 987-654-3210 

Example 2: Extracting URLs from text
URLs found in the text: https://www.example.com http://another.example.org 

Example 3: Matching email addresses in text
Email addresses found in the text: email@example.com another.email@example.org 

Example 4: Finding dates in text
Dates found in the text: 2024-02-15 2024/02/20

Overall, regular expressions in Java provide a flexible and powerful way to work with strings, allowing you to perform complex matching and manipulation operations with relatively simple patterns.

Next TopicJava Exception Handling

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

Interview Questions

Python Java Data Structure C++ C HTML JavaScript jQuery SQL Power BI

Online Compilers

C Compiler R Compiler C++ Compiler PHP Compiler Java Compiler HTML Editor Swift Compiler Python Compiler JavaScript Editor TypeScript Editor

Latest Post | Tutorials List | Privacy Policy | About Us | Contact Us

Java Regular Expressions (Regex)

java.util.regex package

Matcher class

Pattern class

Example of Java Regular Expressions

Example

Output

Dot (.) Quantifier in Java Regex

Example

Java Regex Character Classes

Example

Java Regex Quantifiers

Example

Java Regex Metacharacters

Example

More Examples on Java Regex

Example 1: Alphanumeric String Validation (Fixed Length)

Example 2: Mobile Number Validation Using Regex

Example 3: Java Regex Finder Tool

Example 4: Java Regex Features Demonstration

Example 5: Extracting Data Using Regex Patterns

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java I/O

File Handling in Java

Java Serialization

Java Networking

Java Reflection

Java Collections

Java 5 Features

Java 8 Features

Java JDBC

RMI

Internationalization

Java Projects

Java Regular Expressions (Regex)

java.util.regex package

Matcher class

Pattern class

Example of Java Regular Expressions

Example

Output

Dot (.) Quantifier in Java Regex

Example

Java Regex Character Classes

Example

Java Regex Quantifiers

Example

Java Regex Metacharacters

Example

More Examples on Java Regex

Example 1: Alphanumeric String Validation (Fixed Length)

Example 2: Mobile Number Validation Using Regex

Example 3: Java Regex Finder Tool

Example 4: Java Regex Features Demonstration

Example 5: Extracting Data Using Regex Patterns

Subscribe to Tpoint Tech

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers