Introduction
In this article, we will learn about Java Regex and how to use Regex with examples in Java. Java regex is also known as Java Regular Expression.
What is Regex in Java?
Regular expressions or Java Regex is an API built to define string patterns that can be used to read, alter, and delete data. For pattern matching with the regular expressions, Java offers java.util.regex bundle.
In other words, a regular expression is a special sequence of characters that helps us match or find other strings using a special syntax held in a pattern that is used to search, edit, or manipulate text and data.
java.util.regex package
This provides regular expressions with three classes and a single interface. The classes Matcher and Pattern are usually used in standard Java language.
The complete program of the regex package is listed below.
import java.util.regex.Pattern;
public class RegexPackageExample {
public static void main(String args[]) {
System.out.println(Pattern.matches(".y", "toy"));
System.out.println(Pattern.matches("s..", "sam"));
System.out.println(Pattern.matches(".a", "mia"));
}
}
The above program generates the following output.
![regex_package_example_output]()
PatternSyntaxException class
PatternSyntaxException is an unresolved exception object which means a syntax error in a normal speaking pattern.
The complete program of Showing the PatternSyntaxException class example is listed below.
import java.util.regex.Pattern;
public class PatternSyntaxExceptionExample {
public static void main(String... args) {
String regex = "["; // invalid regex
Pattern pattern = Pattern.compile(regex);
}
}
The above program generates the following output.
![pattern_syntax_exception_output]()
Note. In the above example program, we use the invalid syntax of regex. So, when we run the program, it generates the PatternSyntaxException: Unclosed character class near index 0;
java.util.regex.Matcher;
A Matcher entity is a motor that interprets the template against an input string and executes operations of play. Matcher doesn't describe any public builders as the class Template. By calling the matcher method) (You get a Matcher object on a Pattern object.
Methods of Matcher class
public boolean matches()
The matches method is used to check whether the pattern string matches with the matcher string or not. It returns the boolean value. If the string matches, it returns true otherwise false. It does not take any argument. It does not throw any exception.
Syntax
public boolean matches();
The complete program of java.util.regex.Matcher.matches() method is listed below.
import java.util.regex.*;
public class MatchesMethodExample {
public static void main(String[] args) {
boolean result;
// Get the string value to be checked
String value1 = "CsharpCorner";
// Create a pattern from regex
Pattern pattern = Pattern.compile(value1);
// Get the String value to be matched
String value2 = "CsharpC";
// Create a matcher for the input String
Matcher matcher = pattern.matcher(value2);
// Get the current matcher state
System.out.println("result : " + matcher.matches());
}
}
The above program generates the following output.
![matches_examplr_method_output]()
public int start() Method
The start() method is used to get the start subsequence index. public int start() method does not take any argument. It returns the index of the first character matched 0. If the operation fails, it throws IllegalStateException.
Syntax
public int start();
The complete program of java.util.regex.Matcher.start() method is listed below.
import java.util.regex.*;
public class StartMethodExample {
public static void main(String[] args) {
// Get the string value to be checked
String value1 = "CsharpCorner";
// Create a pattern from regex
Pattern pattern = Pattern.compile(value1);
// Get the String value to be matched
String value2 = "Csharp";
// Create a matcher for the input String
Matcher matcher = pattern.matcher(value2);
// Get the current matcher state
MatchResult result = matcher.toMatchResult();
System.out.println("Current Matcher: " + result);
while (matcher.find()) {
// Get the first index of match result
System.out.println(matcher.start());
}
}
}
The above program generates the following output.
![Start_method_example_output]()
public boolean find() Method
The find method is used to find the next subsequence of the input sequence that finds the pattern. It returns a boolean value. If the input string matches, then it returns true otherwise returns false. This method does not take any argument. This method does not throw any exception.
Syntax
public boolean find()
The complete program of java.util.regex.Matcher.find() method is listed below.
import java.util.regex.*;
public class FindMethodExample {
public static void main(String args[]) {
// Get the regex to be checked
String value = "CsharpCorner";
String value1 = "Java Programming";
// Create a string from regex
Pattern pattern = Pattern.compile(value);
Pattern pattern1 = Pattern.compile(value1);
// Get the String for matching
String matchString = "CsharpCorner";
String matchString1 ="Java";
// Create a matcher for the String
Matcher match = pattern.matcher(matchString);
Matcher match1 = pattern.matcher(matchString1);
//find() method
System.out.println(match.find());
System.out.println(match1.find());
}
}
The above program generates the following output.
![find_method_example_output]()
public boolean find(int start) Method
The find(int start) method is used to find the next subsequence of the input sequence that finds the pattern according to the given argument. It returns a boolean value. This method does not take any argument. This method throws IndexOutOfBoundException if the given argument is less than zero or greater than the length of the string.
Syntax
public boolean find(int start);
The complete program of java.util.regex.Matcher.find() method is listed below.
import java.util.regex.*;
public class FindMethodExample2 {
public static void main(String args[]) {
// Get the regex to be checked
String value = "CsharpCorner";
String value1 = "Java Programming";
// Create a string from regex
Pattern pattern = Pattern.compile(value);
Pattern pattern1 = Pattern.compile(value1);
// Get the String for matching
String matchString = "CsharpCorner";
String matchString1 = "Java";
// Create a matcher for the String
Matcher match = pattern.matcher(matchString);
Matcher match1 = pattern.matcher(matchString1);
//find() method
System.out.println(match.find(3));
System.out.println(match1.find(6));
}
}
The above program generates the following output.
![find_example_method2_output]()
public int end() Method
The end method is used to get the offset after the last match of the character is done. This method doesn't take any argument. this method throws IllegalStateException if the operation fails.
Syntax
public int end()
The complete program example of java.util.regex.Matcher.end() is listed below.
import java.util.regex.*;
public class endMethodExample {
public static void main(String[] args) {
// TODO Auto-generated method stub
Pattern p=Pattern.compile("Hello C#Corner");
Matcher m=p.matcher("Hello C#Corner");
if(m.matches())
System.out.println("Both are matching till "+m.end()+" character");
else
System.out.println("Both are not matching"+m.end());
}
}
The above program generates the following output.
![end_method_example_output]()
java.util.regex.Pattern
A Pattern object is a compiled representation of a regular expression. There are no Template-level public designers. To construct a template, you first need to invoke one of its public static compiles (methods that subsequently return a Template item, which acknowledges a regular expression as the first statement
It is the compiled form of a regular expression and is used to describe the Regex engine template.
Methods of Pattern Class
static Pattern compile(String regex)
The compile() method is used to match a text from a regular expression(regex) pattern. If the operation fails, it returns false otherwise true. This method takes a pattern string value as the argument.
Syntax
static Pattern compile(String regex)
The complete program of the java.util.regex.pattern.compile();
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CompileMethodExample {
public static void main(String args[]) {
// Get the string value to be checked
Pattern p = Pattern.compile(".o");
//Matcher string for
Matcher m = p.matcher("to");
boolean m1 = m.matches();
System.out.println(m1);
}
}
The above program generates the following output.
![compile_method_example_output]()
public boolean matches(regex, String)
The matches() method is used to check whether the given string matches the given regular expression or not. This method returns the boolean value true if the string matches the regex otherwise, it returns false. If the syntax is invalid, then this method throws PatternStateException.
This method takes two arguments.
- regex: This argument is the regular expression value that has to be checked from the string.
- String: This string value has to be checked from the regex through the matches() method.
The complete program of the public boolean matches(regex, String) method is listed below.
import java.util.regex.Pattern;
public class PatternClassMatchesMethod {
public static void main(String args[]) {
System.out.println(Pattern.matches("[bad]", "abcd"));
System.out.println(Pattern.matches("[as]", "a"));
System.out.println(Pattern.matches("[ass]", "asssna"));
}
}
The above program generates the following output.
![pattern_class_matches_method_output]()
Summary
In this article, we learned about Java Regular Expression(regex) in Java Programming Language and the various methods of regex.