Regular Expressions in Java (Java Regex)

Regular expressions in Java are used for pattern matching. Java has a built-in package java.util.regex that supports the use of regular expressions. It is used to validate user input, parse logs, or transform strings. In this guide, we will learn the key concepts of Java regular expressions, the core classes and interfaces involved, common patterns like character classes and quantifiers, and practical use cases with code examples.

Table of Contents:

• What is a Regular Expression in Java?
• Rules of Writing Java Regex
• Regex Classes and Interfaces in Java
• Basic Regular Expression in Java
  • Literals
  • Character Classes
  • Predefined Character Classes
  • Quantifiers
  • Anchors
  • Special Symbols
  • Flags
• Common Use Cases of Regular Expressions in Java
• Tips for Working with Regular Expressions in Java
• Conclusion

What is a Regular Expression in Java?

Java Regular Expression (Java regex) is a sequence of characters that defines a search pattern, usually used for string matching or string manipulation. Java provides built-in support for regular expressions through the java.util.regex package. Java regex allows you to

• Validate inputs (like email, phone, date, etc.)
• Search within strings
• Replace substrings
• Split strings based on complex patterns

Rules of Writing Java Regex

Below are the rules to write a regular expression in Java.

• Java regex has special meaning, if you want to match them, you must escape them using double backslashes.
• Combine patterns like characters, anchors, quantifiers, and so on to maintain an accurate and consistent regex pattern.
• Use anchors like ^ and $ to restrict the match for the matching input, it will help you to avoid mismatched patterns.
• Empty patterns in regular expressions are invalid, hence, don’t use them, as they can lead to confusion.

Master Java Today - Accelerate Your Future

Enroll Now and Transform Your Future

Explore Program

Regex Classes and Interfaces in Java

The Java regex package includes the following classes and interfaces.

Regex Classes in Java

The java.util.regex package includes the following main classes:

1. Pattern class: The Pattern class in Java represents a compiled regular expression. It is used to define, compile, and match regex patterns of character sequences like a String. It is immutable and thread-safe, and is used with the Matcher class to match a pattern.

Methods of the Pattern class in Java regex are as follows:

Example:

Output:

Explanation: The above Java program first compiles a regular expression using Pattern.compile(“\d+”), where \d+ is a regex that matches one or more digits. Then, a Matcher object is created with the matcher() method to apply this pattern to the input string “Order 12345”. If the digits are found in the find() method, then it is printed.

2. Matcher class: The Matcher class in Java is used to perform matching operations like searching, replacing, and verifying patterns on character sequences using a compiled Pattern. It works with the Pattern class and provides a method to find, match, and replace text using regex.

Methods of the Matcher class in Java regex are as follows:

Example:

Output:

Explanation: In the above example, the Matcher class is used to apply the regular expression by the object to a specific input string, Order 12345. The find() method is used to search the input string for the next substring that matches the pattern, i.e., one or more digits.

Regex Interface in Java

Java Regex has the MatchResult interface that provides only read-only access to the results of a regular expression match performed by the Matcher class. It provides a safe access to match groups and allows extraction of matched substrings, start and end indices without modifying the matcher.

Methods of the MatchResult interface in Java regex are as follows:

Example:

Output:

Explanation: In the above example, the MatchResult interface is used to find the matched string, the start index of the matched string, and its end index. The Matcher class implements MatchResult, which is used to find the above output.

Basic Regular Expression in Java

Below are some basic Java regex:

1. Literals

A literal is used to match the exact character or sequence of characters as written. When a literal is given in a regex, it is used to find the exact match of it. For example, the regex cat will only match the string “cat”, not “Cat”, “catalog”, or “scat”.

Example:

Output:

Explanation: In the above example, the literal input is matched with the pattern string; if the literal is matched, the output is displayed as match found with the matched; otherwise, no match found is displayed.

2. Character Classes

A character class is used to match exactly one character from a set of characters. It is defined using square brackets [ ]. For example,

Example:

Output:

Explanation: In the above example, the digits from the string input are matched with the regex string, using a character class. The output is displayed as a digit found with the digit.

3. Predefined Character Classes

The predefined character classes are the shorthand notations in regular expressions that match common character sets like digits, white spaces, or word characters. They are the shortcuts to avoid writing long character classes like those shown above.

Example:

Output:

Explanation: In the above example, the string input is matched with the regex string using a character class. The output is displayed without whitespaces.

4. Quantifiers

Quantifiers in regex specify how many times a character, group, or character class must occur in a match, and are used for repeat patterns.

Example:

Output:

Explanation: In the above example, the string input is matched with the regex string using quantifiers to match 2 to 4 consecutive lowercase letters.

5. Anchors

Anchors are special characters in regex that match the positions of the characters in an expression.

Example:

Output:

Explanation: In the above example, the string input is matched with the regex string using anchors that find the match of end at the end of the input.

6. Special Symbols

In regular expressions, certain characters have special meanings; they are meta-characters used to control pattern matching. If you want to match them as normal characters, you must escape them using a backslash ().

Note: In Java, since is also an escape character in strings, you need to double it as \\.

Note: In Java code, use \\. to match a literal dot because backslash must be escaped in strings.

Example:

Output:

Explanation: In the above example, the string input is matched with the regex string to find a symbol $ as a literal special symbol in the regular expression.

7. Flags

Flags are optional parameters that can be applied when compiling a regex using Pattern.compile() method to modify the behaviour of the pattern matching, such as making it case-insensitive or allowing multiline matching.

Example:

Output:

Explanation: In the above example, the string input is matched with the regex string irrespective of the case sensitivity of the characters, by using the Pattern.CASE_INSENSITIVE flag.

Common Use Cases of Regular Expressions in Java

Below are some common use cases of regular expressions in Java.

1. Validating an Email Address

Below is a simple program to validate an email address in Java.

Output:

Explanation: In the above Java program, an array of strings is named emails. The array is further matched with the regex string and matched using the Pattern.compile() method.

2. Splitting Text Based on a Pattern

Below is a simple program to split a text based on a comma in Java.

Output:

Explanation: In the above Java program, the string input is split into different parts with the context of a comma, by the help of .split() method.

3. Replacing Text with Regex

Java has built-in regex methods to replace substrings based on a pattern. These are

• String.replaceAll(String regex, String replacement): This method is used to replace all the occurrences of the regex pattern with the replacement string.
• String.replaceFirst(String regex, String replacement): This method is used to replace only the first occurrence of the regex pattern with the replacement string.

Example:

Output:

Explanation: In the above example, the string input is first used with the .replaceAll() method that replaces all the occurrences of apple with orange. Then the method replaceFirst() is used to replace the first occurrence of apple with orange.

Tips for Working with Regular Expressions in Java

Some of the tips while you are using the Java regex are as follows:

• To improve your code performance, compile the regex using Pattern.compile() only once, and reuse it. Because every time you call this method, Java has to parse and compile the whole regular expression, hence wasting resources.
• Keep the regex pattern simple and readable, so that it can be quickly understood and debugged by the compiler, which also helps reduce the risk of errors.
• Java regex has multiple predefined character classes to make your patterns shorter, readable, and easier to maintain, hence, instead of writing complex custom characters, you can use built-in classes or methods to match the common character types.
• Use quantifiers to match how many times the pattern has occurred, which lets you match single, multiple, or optional occurrences of elements, depending on your data.

Unlock Your Future in Java

Start Your Java Journey for Free Today

Explore Program

Conclusion

Java regex is very helpful for developers to work with text processing, data manipulation, and so on. The package java.util.regex allows the user to use different kinds of interfaces and classes with the built-in methods like find(), start(), end(), and so on to use the regular expression easily. You can use anchors, characters, quantifiers, flags, special symbols, and so on to solve many problems, like validating an email address.

Java Regex – FAQs