Home > Java > javaTutorial > Regular Expressions in Java

Regular Expressions in Java

WBOY
Release: 2024-08-30 15:33:26
Original
353 people have browsed it

In Java, Regex or Regular Expression is an Application Program Interface that helps define a pattern to search, manipulate, and edit strings. Java regular expressions are widely used in the validation of passwords and emails. These expressions are provided by java.util.regex package and consists of 1 interface and 3 classes.

The three classes are:

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

  • Pattern: Helps in defining patterns.
  • Matcher: Using patterns helps in performing match operations.
  • PatternSyntaxException: Helps in indicating a syntax error.

Java Regex has one interface known as MatchResultInterface that helps in determining the regular expression’s match operation result.

Syntax of Regular Expression in Java

Let us see how to write a regular expression in Java with the help of a program.

Code:

//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples {
public static void main(String args[]){
String A = " Happiness is " + " within yourself";
String B = ".*within.*";
// checks whether the string A contains the word 'within' and stores the result in matchcheck
boolean matchcheck = Pattern.matches(B, A);
//prints the result
System.out.println("Is there any string 'within' in the text ? \n " + matchcheck);
}   }
Copy after login

Output:

Regular Expressions in Java

Commonly Used Methods in Regular Expressions

There are 3 commonly used methods in regular expressions.

1. Index Methods

Index methods offer index values that help in precisely showing where the match was found in the string given as input.

Method Description
start() The previous match’s start index is returned.
start(int group) Given the group’s previous match operation, the subsequence is captured and returned.
end() The offset after matching the last character is returned.
End(int group) Given the group’s previous match operation, subsequence is captured and offset after matching its last character returned.
Method

Description

start() The previous match’s start index is returned.
start(int group) Given the group’s previous match operation, the subsequence is captured and returned.
end() The offset after matching the last character is returned.
End(int group) Given the group’s previous match operation, subsequence is captured and offset after matching its last character returned.
2. Study Methods
Method Description
lookingAt() Match the sequence given as input against the pattern from the beginning of the region.
find() Finds the next subsequence of the sequence given as input against the pattern from the beginning of the region.
find(int start) Resets the matcher and then finds the next subsequence of the sequence given as input against the specified index pattern.
matches() Matches content against the pattern.

Study methods check the string given as input, and a Boolean value is returned, indicating whether the pattern is found or not.

Method

Method Description
appendReplacement(StringBuffer s, String replacement) A non-terminal append and replacement step will be implemented.
appendTail(StringBuffer s) A terminal append and replacement step will be implemented.
replaceAll(String replacement) Replace all subsequence of the sequence given as input that matches against the pattern with a replacement string.
quoteReplacement(String s) A literal replacement string will be returned for the mentioned string.
replaceFirst(String replacement) Replace the first subsequence of the sequence given as input that matches the pattern with a replacement string.
Description
lookingAt() Match the sequence given as input against the pattern from the beginning of the region.
find() Finds the next subsequence of the sequence given as input against the pattern from the beginning of the region.
find(int start) Resets the matcher and then finds the next subsequence of the sequence given as input against the specified index pattern.
matches() Matches content against the pattern.
3. Replacement Methods Methods that are used to replace text in a string.
Method Description
appendReplacement(StringBuffer s, String replacement) A non-terminal append and replacement step will be implemented.
appendTail(StringBuffer s) A terminal append and replacement step will be implemented.
replaceAll(String replacement) Replace all subsequence of the sequence given as input that matches against the pattern with a replacement string.
quoteReplacement(String s) A literal replacement string will be returned for the mentioned string.
replaceFirst(String replacement) Replace the first subsequence of the sequence given as input that matches the pattern with a replacement string.

How to Define Regular Expression in Java?

There are several ways in which a regular expression can be defined.

1. Literals

Suppose a string “hai” has to be searched in the text “hai”.

It can be done using syntax.

Pattern.matches("hai", "hai")
Copy after login

2. Character Classes

It matches every single character in the text given as input against multiple permitted characters in the character class.

The following are the various class constructs.

Character Class Explanation
[pqr] Matches the text if it contains either p, q or r, and it should be only once.
[^pqr] ^ denotes the negation, and due to that, here, single character except for p, q, or r are taken.
[a-zA-Z] a to z and A to Z are considered.
[a-d[p-s]] a to d, or p to s.
[a-dm-p] Union of both ranges.
[a-z&&[pqr]] a to z and (p, q or r).
[a-z&&[^pq]] a to z and also, p, q are not considered.
[ad-z] Performs the subtraction.
[a-z&&[^m-p]] a to z and not m to p.

3. Metacharacters

Metacharacters act like shortcodes in the regular expression.

The following are some of the metacharacters commonly used.

Regular Expression Explanation
\d Any digit from 0 to 9. It can be written as [0-9] as well.
\D Any non-digit from 0 to 9. It can be written as [^0-9] as well.
\s Whitespace character or [\t\n\x0B\f\r].
\S Non whitespace character or [^\s].
\w Word character or [a-zA-Z_0-9].
\W Non-word character or [^\w].
\b Word boundary.
\B Non-word boundary.

4. Quantifiers

Quantifiers mention the count of occurrence of each character to match against the string.

Regular Expression Explanation
a? It occurs once or not at all.
A* A occurs 0 or more times.
A+ A occurs 1 or more times.
A{n} A occurs exactly n times.
A{n,} A occurs n or more than that.
A{n,m} A occurs at least n times, but it should not be more than m times.

How to Create Regular Expression in Java?

Now, let us see a java program with the above-mentioned regular expressions.

Code:

//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples {
public static void main(String args[]){
String str="hai";
// Returns true if string 1 matches string 2
System.out.println("Returns true if 'hai' matches 'Hai' :"+
Pattern.matches(str, "Hai")); //False
//Returns true if Hai or hai matches parameter 2
System.out.println("Returns true if 'Hai' or 'hai' matches 'Hai' : "+
Pattern.matches("[Hh]ai", "Hai")); //True
// Returns true if the string matches exactly "ann" or "Ann" or "jak" or "Jak"
System.out.println("Returns true if the string matches exactly 'ann' or 'Ann' or 'jak' or 'Jak' with 'Ann' : "+
Pattern.matches("[aA]nn|[jJ]ak", "Ann"));//True
//returns true if the string contains "with" at any place in the string
System.out.println("returns true if the string contains 'with' in the string 'within' : " +
Pattern.matches(".*with.*", "within"));//True
// returns true if the '9448anna' does not have number in the beginning
System.out.println( "returns true if the '9448anna' does not have number in the beginning : "+
Pattern.matches("^[^\\d].*", "9448anna")); //False
System.out.println("returns true if the '9448anna' does not have number in the beginning : " +
Pattern.matches("^[^\\d].*", "anna9448")); //True
}
}
Copy after login

Output:

Regular Expressions in Java

Conclusion – Regular Expressions in Java

Java Regular Expressions are widely used for real-time applications such as password and email verification. These expressions are APIs that define patterns and offer searching, editing, and several other operations in the string.

The above is the detailed content of Regular Expressions in Java. For more information, please follow other related articles on the PHP Chinese website!

Related labels:
source:php
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template