Java

Regular Expressions in Java | Explained

A regular expression (also known as regex) provides an API that defines the patterns to search or manipulate the strings. In Java, a predefined package java.util.regex can be used to work with the regular expressions. It consists of three classes: a Pattern class to define a pattern, a Matcher class to search a pattern, and a PatternSyntaxException class to indicate a syntax error in a regex pattern.

This write-up presents a thorough understanding of the following concepts:

  • Pattern Creation using Compile Method
  • Pattern Matching using Matcher Method
  • What are Flags in Regular Expressions
  • What are Regular Expression Patterns
  • What are MetaCharacters in Regular Expressions
  • What are Quantifiers in Regular Expressions
  • Practical Implementation of Regular Expressions in Java

So, let’s get started!

Pattern Creation using Compile() Method

In order to create a pattern, firstly we have to invoke the compile() method of the Pattern class and as a result, it will return a pattern object. The compile() method can take two parameters: first one for the pattern to be searched and the second one is optional and can be used to specify a flag.

What are Patterns in Regular Expressions

In the first parameter, the compile() method specifies a pattern to be searched. Some commonly used search patterns are listed below:

  1. [—] here “—” represents different characters, and the entire pattern i.e. [—] describes that find a character between the options provided within the brackets.
  2. [^—] describes finding a character that is not a part of the provided pattern.
  3. [0-9], describes finding a number between 0 to 9.

What are Flags in Regular Expressions

Flags are optional parameters to the regular expressions and can be used to specify their(regular expressions) searching behavior. For example, CASE_INSENSTIVE can be used to perform the search irrespective of the letter’s case, i.e. uppercase or lowercase.

Pattern Matching using Matcher() Method

The pattern returned by the compile() method will be interpreted by the matcher() method to perform the match operation over the String.

What are MetaCharacters in Regular Expressions

Java provides several Metacharacters that have some special meaning and are helpful in defining the search criteria:

MetaCharacters Description
\d Used to find a digit
\b Used to find a match at the start or end of the word
$ Used to find the match at the end of the string
^ Used to find the match at the start of the string
\s Search for the white spaces
| Search for a match from multiple options that are separated with ‘|’ sign
. Used to match a single instance of a character

What are Quantifiers in Regular Expressions

Quantifier specifies the number of occurrences to be matched, some commonly used quantifiers are listed below:

Quantifiers Description
A+ A occurs at least one time
A* A occurs zero or more time
A? A occurs either zero time or one time
A{n} A occurs n number of times
A{n,} A occurs n times or more than n times
A{x,y} A occurs between the provided range i.e. A occurs at least x times but less than y times

Practical Implementation of Regular Expressions in Java

Let’s implement the above-mentioned concepts in a practical scenario for a profound understanding.

Example

In the below code snippet, we searched for the word “linuxhint” in a sentence using a regular expression:

publicclassRegexpExample {
    publicstaticvoidmain(String[] args) {
    Pattern pat = Pattern.compile("LinuxHint", Pattern.CASE_INSENSITIVE);
    Matcher match = pat.matcher("Welcome to linuxhint.com");
    boolean found = match.find();
    if (found) {
    System.out.println("Match found successfully");
    } else {
    System.out.println("Match not found");
    }
    }
}

Initially, we created the object of the Pattern class, then we specify a word that we want to search and a flag “CASE_INSENSITIVE” within the compile() method. Next, we utilize the matcher() method to perform the match operation over the String.

The output authenticates that matches are found successfully regardless of case sensitivity.

Conclusion

The regular expressions are nothing but a sequence of characters that defines the search patterns. In java, regular expressions are used to search, edit, and manipulate a string. To create a pattern, first we have to invoke the compile() method of the Pattern class and consequently, it will return a pattern which will be interpreted by the matcher() method to perform the match operation over the String. Moreover, Java provides several Metacharacters that are helpful in defining the searching criteria and Quantifiers to specify the number of occurrences to be matched.

About the author

Anees Asghar

I am a self-motivated IT professional having more than one year of industry experience in technical writing. I am passionate about writing on the topics related to web development.