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.
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.
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 regex package is listed below.
PatternSyntaxException class
PatternSyntaxException is a 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 = "[";
- Pattern pattern = Pattern.compile(regex);
- }
- }
The above program generates the following 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;
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 the pattern string is matches with 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;
-
- String value1 = "CsharpCorner";
-
-
- Pattern pattern = Pattern.compile(value1);
-
-
- String value2 = "CsharpC";
-
-
- Matcher matcher = pattern.matcher(value2);
-
-
- System.out.println("result : " + matcher.matches());
- }
- }
The above program generates the following 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 is failed 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) {
-
-
- String value1 = "CsharpCorner";
-
-
- Pattern pattern = Pattern.compile(value1);
-
-
- String value2 = "Csharp";
-
- Matcher matcher = pattern.matcher(value2);
-
-
- MatchResult result = matcher.toMatchResult();
- System.out.println("Current Matcher: " + result);
-
- while (matcher.find()) {
-
- System.out.println(matcher.start());
- }
- }
- }
The above program generates the following 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[]) {
-
- String value = "CsharpCorner";
- String value1 = "Java Programming";
-
-
- Pattern pattern = Pattern.compile(value);
- Pattern pattern1 = Pattern.compile(value1);
-
-
- String matchString = "CsharpCorner";
- String matchString1 ="Java";
-
-
- Matcher match = pattern.matcher(matchString);
- Matcher match1 = pattern.matcher(matchString1);
-
- System.out.println(match.find());
- System.out.println(match1.find());
-
- }
- }
The above program generates the following 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 then zero or greater then 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[]) {
-
- String value = "CsharpCorner";
- String value1 = "Java Programming";
-
-
- Pattern pattern = Pattern.compile(value);
- Pattern pattern1 = Pattern.compile(value1);
-
-
- String matchString = "CsharpCorner";
- String matchString1 = "Java";
-
-
- Matcher match = pattern.matcher(matchString);
- Matcher match1 = pattern.matcher(matchString1);
-
- System.out.println(match.find(3));
- System.out.println(match1.find(6));
-
- }
- }
The above program generates the following 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) {
-
- 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.
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 which 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 is failed 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[]) {
-
-
- Pattern p = Pattern.compile(".o");
-
-
- Matcher m = p.matcher("to");
- boolean m1 = m.matches();
- System.out.println(m1);
- }
- }
The above program generates the following output.
public boolean matches(regex, String)
The matches() method is used to check 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 which has to check from the string.
- String- This string value has to check 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.
Summary
In this article, we learned about Java Regular Expression(regex) in Java Programming Language and the varoius methods of regex.