20. Java Regex

🚀 Master Java regular expressions! Learn to write powerful regex expressions, utilize the Matcher & Pattern classes, understand quantifiers and character classes. Become a regex pro! 🥇

Posted Jan 21, 2025 Updated Jan 21, 2025

By Youth Innovations

11 min read

20. Java Regex

What we will learn in this post?

👉 Introduction to Java Regex
👉 How to Write Regex Expressions
👉 Matcher Class
👉 Pattern Class
👉 Quantifiers
👉 Character Class
👉 Conclusion!

Java Regex: Mastering Pattern Matching ✨

Java Regular Expressions (Regex or regexp) are powerful tools for searching and manipulating text. They provide a concise way to define patterns for matching specific sequences of characters within strings. Think of them as sophisticated “find and replace” on steroids! 💪

Purpose of Java Regex 🔎

Regex is used extensively for:

Pattern Matching: Finding specific text within larger strings (e.g., finding all phone numbers in a document).
String Validation: Ensuring strings conform to a specific format (e.g., verifying email addresses or passwords).
String Manipulation: Extracting parts of strings, replacing text, and splitting strings based on patterns.

Example: Email Validation ✉️

Let’s validate an email address using a simple regex:

  
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EmailValidator {
    public static void main(String[] args) {
        String email = "test@example.com";
        String regex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);

        if (matcher.matches()) {
            System.out.println("Valid email address!");
        } else {
            System.out.println("Invalid email address!");
        }
    }
}

This code will output: Valid email address!

This example uses a fairly robust regex (^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$) to check if the email string matches a common email format. Remember that perfect email validation is complex; this regex provides a reasonable but not foolproof solution.

Using Regex in Java Applications 💻

Java’s java.util.regex package provides classes like Pattern and Matcher to work with regular expressions. The Pattern class compiles the regex into a usable form, and the Matcher class performs the matching operation against the target string.

Learn more about Java Regex

Note: Regex syntax can be tricky to master, but with practice, it becomes a valuable skill for any Java developer. There are many online resources and tools to help you learn and test your regex patterns.

Regular Expressions (Regex) in Java: A Friendly Guide 📖

Regular expressions, or regex for short, are powerful tools for pattern matching within strings. Think of them as search commands on steroids! They let you find specific sequences of characters, regardless of their position within a larger text. Java has robust support for regex through the java.util.regex package. Let’s explore the syntax and structure in a simple, easy-to-understand way.

Basic Syntax and Structure 🤔

A regex is essentially a pattern described using a specific syntax. This syntax uses special characters (called metacharacters) to represent different types of characters or character sequences. Here are some common ones:

Common Metacharacters

. : Matches any single character (except newline).
* : Matches zero or more occurrences of the preceding character.
+ : Matches one or more occurrences of the preceding character.
? : Matches zero or one occurrence of the preceding character.
[] : Matches any single character within the brackets. [abc] matches ‘a’, ‘b’, or ‘c’. [a-z] matches any lowercase letter.
[^] : Matches any single character not within the brackets. [^0-9] matches any non-digit character.
() : Creates a capturing group. This allows you to extract specific parts of a matched string.
\ : Escapes a metacharacter (treats it literally). For example, \. matches a literal dot.
^ : Matches the beginning of a line.
$ : Matches the end of a line.

Examples of Common Patterns 🎯

Let’s look at some examples demonstrating how to use these metacharacters:

Matching Digits

\d : Matches any digit (0-9). \d{3} matches exactly three digits.
[0-9] : Equivalent to \d.

Matching Words

\w : Matches any alphanumeric character (a-z, A-Z, 0-9, and underscore). \w+ matches one or more alphanumeric characters (a word).
[a-zA-Z]+ : Matches one or more letters (a word, excluding numbers and underscore).

Matching Special Characters

\s : Matches any whitespace character (space, tab, newline).
. : Matches any character (except newline). To match a literal dot, use \..

Phone Number Matching Example 📞

Let’s create a Java program that matches a North American phone number in the format XXX-XXX-XXXX:

  
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PhoneNumberRegex {
    public static void main(String[] args) {
        String phoneNumber = "123-456-7890";
        String regex = "\\d{3}-\\d{3}-\\d{4}"; //Regex for phone number

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(phoneNumber);

        if (matcher.matches()) {
            System.out.println("Valid phone number: " + phoneNumber);
        } else {
            System.out.println("Invalid phone number: " + phoneNumber);
        }
    }
}

This code first defines the regex pattern \d{3}-\d{3}-\d{4}. Then, it compiles the pattern into a Pattern object and creates a Matcher object to test the phone number against the pattern. The matches() method checks if the entire string matches the pattern.

Output:

Valid phone number: 123-456-7890

More Resources & Further Learning 🚀

Oracle Java Documentation on java.util.regex: https://docs.oracle.com/javase/8/docs/api/java/util/regex/package-summary.html
Online Regex Testers: Many websites offer interactive regex testers where you can experiment with patterns and see how they work. A quick search for “regex tester” will give you plenty of options.

This guide provides a foundation for understanding and using regex in Java. Remember that regular expressions can get quite complex, but mastering the basics will empower you to work with text data more efficiently! Happy regex-ing! 🎉

Java’s Matcher Class: A Friendly Guide to Pattern Matching 🔎

The Matcher class in Java is your best friend when it comes to finding patterns in text using regular expressions (regex). It works hand-in-hand with the Pattern class. Think of Pattern as compiling your regex into a usable form, and Matcher as the engine that searches your text for matches.

Key Methods and Functionality ✨

The Matcher class offers several useful methods for regex operations:

matches(): Checks if the entire input sequence matches the pattern.
find(): Searches for the next occurrence of the pattern. This is crucial for finding multiple matches.
group(): Retrieves the matched substring.
start() and end(): Get the starting and ending indices of the matched substring.

Finding Multiple Occurrences Example

Let’s see how to find all occurrences of “cat” in a string:

  
import java.util.regex.*;

public class MatcherExample {
    public static void main(String[] args) {
        String text = "The cat sat on the mat.  Another cat appeared.";
        Pattern pattern = Pattern.compile("cat");  //Compile the regex
        Matcher matcher = pattern.matcher(text); // Create the matcher

        while (matcher.find()) { //Find all occurrences
            System.out.println("Found 'cat' at index: " + matcher.start());
        }
    }
}

This code will output:

Found 'cat' at index: 4
Found 'cat' at index: 34

Visual Representation 📊

graph TD
    A["🔍 Pattern Compilation"] --> B{"🛠 Matcher Creation"};
    B --> C["🔎 find() Method"];
    C -- "✅ Match Found" --> D["📋 group(), start(), end()"];
    C -- "❌ No Match" --> E["🚫 End of Search"];
    D --> F["📤 Output Results"];
    E --> F;

    classDef processStyle fill:#4CAF50,stroke:#388E3C,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10,shadow:3px;
    classDef decisionStyle fill:#FF9800,stroke:#F57C00,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10,shadow:3px;
    classDef successStyle fill:#2196F3,stroke:#1976D2,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10,shadow:3px;
    classDef failureStyle fill:#F44336,stroke:#D32F2F,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10,shadow:3px;
    classDef outputStyle fill:#FFC107,stroke:#FFA000,color:#000000,font-size:14px,stroke-width:2px,rx:10,shadow:3px;

    class A processStyle;
    class B decisionStyle;
    class C processStyle;
    class D successStyle;
    class E failureStyle;
    class F outputStyle;

This flowchart shows the process of using Matcher to find multiple occurrences.

For more detailed information and advanced regex techniques, check out the official Java documentation: https://docs.oracle.com/javase/7/docs/api/java/util/regex/Matcher.html

Remember, the Matcher class is a powerful tool for text processing in Java. Mastering it will significantly enhance your ability to work with strings and patterns effectively! 👍

Java’s `Pattern` Class: Your Regex Friend 🤝

Regular expressions (regex or regexp) are powerful tools for text manipulation. In Java, the Pattern class is your key to harnessing this power efficiently. It handles the compilation of regex expressions, making your code faster and more readable.

Compiling Regex: The `compile()` Method

The core function of Pattern is to compile your regex string into a reusable Pattern object. This compilation step is crucial because it transforms the human-readable regex into a format that the Java Virtual Machine (JVM) can understand and process quickly. Once compiled, you can reuse the Pattern object multiple times without recompiling, enhancing performance.

Example: Compiling and Reusing

  
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexExample {
    public static void main(String[] args) {
        // Compile the regex only once
        Pattern pattern = Pattern.compile("\\d+"); // Matches one or more digits

        // Reuse the pattern for multiple strings
        Matcher matcher1 = pattern.matcher("My number is 12345");
        Matcher matcher2 = pattern.matcher("Another number: 6789");

        System.out.println(matcher1.find() ? matcher1.group() : "No match"); // Output: 12345
        System.out.println(matcher2.find() ? matcher2.group() : "No match"); // Output: 6789
    }
}

This code compiles \d+ (one or more digits) once and then reuses it. This avoids redundant compilation, boosting efficiency, especially when dealing with many strings and the same regex.

Key `Pattern` Methods

compile(String regex): Compiles a regex string.
matcher(CharSequence input): Creates a Matcher object to apply the compiled pattern to an input string. The Matcher class provides methods like find(), matches(), and group() for extracting matched parts.

Why Use `Pattern`?

Using Pattern offers these benefits:

Improved Performance: Compilation speeds up matching.
Code Readability: Separates regex compilation from its application.
Reusability: Compile once, use many times.

For more detailed information, you can refer to the official Java documentation on Pattern. Happy regexing! 🎉

Java Regex Quantifiers Explained 🎉

Quantifiers in Java regular expressions are special characters that control how many times a part of a pattern must occur to match successfully. They’re super useful for flexible pattern matching! Think of them as specifying the quantity of something you’re looking for.

Understanding Quantifiers

Let’s explore some key quantifiers:

*: Matches zero or more occurrences of the preceding element.
+: Matches one or more occurrences.
{n}: Matches exactly n occurrences.
{n,}: Matches at least n occurrences.
{n,m}: Matches between n and m occurrences (inclusive).

Examples with Code & Output

Let’s see them in action! We’ll use the String.matches() method for our examples.

  
String text = "colouur";

System.out.println(text.matches("colou?r")); // true (u appears 0 or 1 time)
System.out.println(text.matches("colou+r")); // true (u appears 1 or more times)
System.out.println(text.matches("colou{2}r")); // true (u appears exactly 2 times)
System.out.println(text.matches("colou{1,}r")); //true (u appears 1 or more times)
System.out.println(text.matches("colou{1,3}r")); // true (u appears between 1 and 3 times)

Here’s a simple flowchart illustrating how * works:

graph TD
    A["✏️ Input String"] --> B{"❓ Does the preceding element exist?"};
    B -- "✅ Yes" --> C["✔️ Match"];
    B -- "❌ No" --> C;
    C --> D["🔄 Continue Matching"];

    classDef processStyle fill:#4CAF50,stroke:#388E3C,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10,shadow:3px;
    classDef decisionStyle fill:#FF9800,stroke:#F57C00,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10,shadow:3px;
    classDef matchStyle fill:#2196F3,stroke:#1976D2,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10,shadow:3px;

    class A processStyle;
    class B decisionStyle;
    class C matchStyle;
    class D processStyle;

Note: The ? quantifier (matching zero or one occurrence) is also a very common and useful quantifier!

More Resources 📚

For a deeper dive into Java regular expressions, check out these resources:

Remember, mastering quantifiers is key to effectively using Java regular expressions for pattern matching and text manipulation! ✨

Character Classes in Java Regex 🔎

Regular expressions (regex or regexp) are powerful tools for pattern matching in strings. Java’s regex engine uses character classes to define sets of characters you want to match. Instead of listing each character individually, you can use shorthand notations.

Defining Character Sets 🎯

Character classes are defined using square brackets [].

[abc] matches ‘a’, ‘b’, or ‘c’.
[a-z] matches any lowercase letter.
[A-Z] matches any uppercase letter.
[0-9] matches any digit.
[a-zA-Z0-9] matches any alphanumeric character.
[^abc] matches any character except ‘a’, ‘b’, or ‘c’ (negation).

Example: Matching Vowels 🎤

Let’s match all vowels (a, e, i, o, u) in a string:

  
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class VowelMatcher {
    public static void main(String[] args) {
        String text = "Hello, World!";
        String regex = "[aeiou]"; // Character class for vowels

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE); //Case insensitive matching
        Matcher matcher = pattern.matcher(text);

        while (matcher.find()) {
            System.out.println("Vowel found: " + matcher.group());
        }
    }
}