Regex java

❮ PreviousNext ❯

What is a Regular Expression?

A regular expression is a sequence of characters that forms a search pattern. When you search for data in a text, you can use this search pattern to describe what you are searching for.

A regular expression can be a single character, or a more complicated pattern.

Regular expressions can be used to perform all types of text search and text replace operations.

Java does not have a built-in Regular Expression class, but we can import the package to work with regular expressions. The package includes the following classes:

• Class - Defines a pattern (to be used in a search)
• Class - Used to search for the pattern
• Class - Indicates syntax error in a regular expression pattern

Example Explained

In this example, The word "w3schools" is being searched for in a sentence.

First, the pattern is created using the method. The first parameter indicates which pattern is being searched for and the second parameter has a flag to indicates that the search should be case-insensitive. The second parameter is optional.

The method is used to search for the pattern in a string. It returns a Matcher object which contains information about the search that was performed.

The method returns true if the pattern was found in the string and false if it was not found.

Flags

Flags in the method change how the search is performed. Here are a few of them:

• - The case of letters will be ignored when performing a search.
• - Special characters in the pattern will not have any special meaning and will be treated as ordinary characters when performing a search.
• - Use it together with the flag to also ignore the case of letters outside of the English alphabet

Regular Expression Patterns

The first parameter of the method is the pattern. It describes what is being searched for.

Brackets are used to find a range of characters:

Metacharacters

Metacharacters are characters with a special meaning:

Quantifiers

Quantifiers define quantities:

❮ PreviousNext ❯

next →← prev

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

It is widely used to define the constraint on strings such as password and email validation. After learning Java regex tutorial, you will be able to test your regular expressions by the Java Regex Tester Tool.

Java Regex API provides 1 interface and 3 classes in 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.

1. MatchResult interface
2. Matcher class
3. Pattern class
4. 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.

Pattern class

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

Example of Java Regular Expressions

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

Output

Regular Expression . Example

The . (dot) represents a single character.

Regex Character classes

Regular Expression Character classes Example

Regex Quantifiers

The quantifiers specify the number of occurrences of a character.

Regular Expression Character classes and Quantifiers Example

Regex Metacharacters

The regular expression metacharacters work as shortcodes.

Regular Expression Metacharacters Example

Regular Expression Question 1

Regular Expression Question 2

Java Regex Finder Example

Output:

Next TopicJava Exception Handling

← prevnext →

Java provides the java.util.regex package for pattern matching with regular expressions. Java regular expressions are very similar to the Perl programming language and very easy to learn.

A regular expression is a special sequence of characters that helps you match or find other strings or sets of strings, using a specialized syntax held in a pattern. They can be used to search, edit, or manipulate text and data.

The java.util.regex package primarily consists of the following three classes −

• Pattern Class − A Pattern object is a compiled representation of a regular expression. The Pattern class provides no public constructors. To create a pattern, you must first invoke one of its public static compile() methods, which will then return a Pattern object. These methods accept a regular expression as the first argument.

• Matcher Class − A Matcher object is the engine that interprets the pattern and performs match operations against an input string. Like the Pattern class, Matcher defines no public constructors. You obtain a Matcher object by invoking the matcher() method on a Pattern object.

• PatternSyntaxException − A PatternSyntaxException object is an unchecked exception that indicates a syntax error in a regular expression pattern.

Capturing Groups

Capturing groups are a way to treat multiple characters as a single unit. They are created by placing the characters to be grouped inside a set of parentheses. For example, the regular expression (dog) creates a single group containing the letters "d", "o", and "g".

Capturing groups are numbered by counting their opening parentheses from the left to the right. In the expression ((A)(B(C))), for example, there are four such groups −

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

To find out how many groups are present in the expression, call the groupCount method on a matcher object. The groupCount method returns an int showing the number of capturing groups present in the matcher's pattern.

There is also a special group, group 0, which always represents the entire expression. This group is not included in the total reported by groupCount.

Example

Following example illustrates how to find a digit string from the given alphanumeric string −

Live Demo

This will produce the following result −

Output

Regular Expression Syntax

Here is the table listing down all the regular expression metacharacter syntax available in Java −

Methods of the Matcher Class

Here is a list of useful instance methods −

Index Methods

Index methods provide useful index values that show precisely where the match was found in the input string −

Study Methods

Study methods review the input string and return a Boolean indicating whether or not the pattern is found −

Replacement Methods

Replacement methods are useful methods for replacing text in an input string −

The start and end Methods

Following is the example that counts the number of times the word "cat" appears in the input string −

Example

Live Demo

This will produce the following result −

Output

You can see that this example uses word boundaries to ensure that the letters "c" "a" "t" are not merely a substring in a longer word. It also gives some useful information about where in the input string the match has occurred.

The start method returns the start index of the subsequence captured by the given group during the previous match operation, and the end returns the index of the last character matched, plus one.

The matches and lookingAt Methods

The matches and lookingAt methods both attempt to match an input sequence against a pattern. The difference, however, is that matches requires the entire input sequence to be matched, while lookingAt does not.

Both methods always start at the beginning of the input string. Here is the example explaining the functionality −

Example

Live Demo

This will produce the following result −

Output

The replaceFirst and replaceAll Methods

The replaceFirst and replaceAll methods replace the text that matches a given regular expression. As their names indicate, replaceFirst replaces the first occurrence, and replaceAll replaces all occurrences.

Here is the example explaining the functionality −

Example

Live Demo

This will produce the following result −

Output

The appendReplacement and appendTail Methods

The Matcher class also provides appendReplacement and appendTail methods for text replacement.

Here is the example explaining the functionality −

Example

Live Demo

This will produce the following result −

Output

PatternSyntaxException Class Methods

A PatternSyntaxException is an unchecked exception that indicates a syntax error in a regular expression pattern. The PatternSyntaxException class provides the following methods to help you determine what went wrong −

Regular Expressions or Regex (in short) is an API for defining String patterns that can be used for searching, manipulating, and editing a string in Java. Email validation and passwords are a few areas of strings where Regex is widely used to define the constraints. Regular Expressions are provided under java.util.regex package. This consists of 3 classes and 1 interface. The java.util.regex package primarily consists of the following three classes as depicted below in tabular format as follows:

Regex in java provides us two classes listed below as follows:

1. Pattern Class
2. Matcher Class

More understanding can be interpreted from the image provided below as follows:

Class 1: Pattern Class 

This class is a compilation of regular expressions that can be used to define various types of patterns, providing no public constructors. This can be created by invoking the compile() method which accepts a regular expression as the first argument, thus returns a pattern after execution.
 

Example: Pattern class 

Class 2: Matcher class

This object is used to perform match operations for an input string in java, thus interpreting the previously explained patterns. This too defines no public constructors. This can be implemented by invoking a matcher() on any pattern object.

Note: that Pattern.matches() checks if the whole text matches with a pattern or not. Other methods (demonstrated below) are mainly used to find multiple occurrences of patterns in the text.

Let us do discuss few sample programs as we did for Pattern class. Here we will be discussing a few java programs that demonstrate the workings of compile(), find(), start(), end(), and split() in order to get a better understanding of the Matcher class.

Example 1: Pattern searching 

Example 2: Simple regular expression searching 

Example 3: Case Insensitive pattern searching  

Example 4: split() method to split a text based on a delimiter pattern.

The string split() method breaks a given string around matches of the given regular expression. There exist two variations of this method so do go through it prior to moving onto the implementation of this method.

Illustration:

Now we are done with discussing both the classes. Now we will be introducing you to two new concepts that make absolute clear Also there is an exception class associated with  

Concept 1: PatternSyntaxException class

This is an object of Regex which is used to indicate a syntax error in a regular expression pattern and is an unchecked exception. Following are the methods been there up in the PatternSyntaxException class as provided below in tabular format as follows.

Concept 2: MatchResult Interface

This interface is used to determine the result of a match operation for a regular expression. It must be noted that although the match boundaries, groups, and group boundaries can be seen, the modification is not allowed through a MatchResult. Following are the methods been there up here in this interface as provided below in tabular format as follows:

Lastly, let us do discuss some of the important observations as retrieved from the above article

1. We create a pattern object by calling Pattern.compile(), there is no constructor. compile() is a static method in Pattern class.
2. Like above, we create a Matcher object using matcher() on objects of Pattern class.
3. Pattern.matches() is also a static method that is used to check if given text as a whole matches pattern or not.
4. find() is used to find multiple occurrences of patterns in the text.
5. We can split a text based on a delimiter pattern using the split() method

This article is contributed by Akash Ojha. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to [email protected] See your article appearing on the GeeksforGeeks main page and help other Geeks. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.