#java regex

There are times when we do not know the exact item but we know how it looks like i.e. it has specific pattern and certain characteristics. So by just knowing the pattern, we can identify the items. In the same way, there are patterns to identify strings or set of strings in given text or file in java. For that, we have a REGULAR EXPRESSION in java. e.g. if we want to catch all email from the given text, we know how emails look like so we can define a pattern. We create a regex to represent that pattern. And performing pattern match on the given text, we can list all the emails in the given input text.

So regular expression is a special sequence of character that helps to match, find, edit other string or set of strings in the given input, using a specialized string held in so-called Pattern. The regular expression in java is provided through java.util.regex package. Java.util.regex primarily contains three classes name listed below

- Pattern Class: It is used to define the patterns for matching. An object of Pattern class represents a compiled representation of the regular expression. There is no public constructor available to create an object of Pattern class. To instantiate an object of Pattern class, one has to use any version of public static compile() method of Pattern class. These methods accept regular expression string as the first argument.

- Matcher Class: Matcher class is an engine to interpret the pattern of regular expression and performs the match on the input string. Matcher class too does not have any public constructor. To obtain an object of Matcher class, one has to use call matcher() method on Pattern Class object.

- PatternSyntaxException Class: A PatternSyntaxException class represents an unchecked exception that indicates a Syntax error in the regular expression.

CAPTURING GROUP in Regular Expression

The capturing group represents the group of the letter put together as a single unit. They are created by putting letters to be grouped in parentheses. e.g. (techie360).

Capturing groups are numbered by counting the opening parentheses from left to right. e.g ((t)(pq)) has capturing group in the order ((t)(pq)), (t), (pq).

To find the number of capturing group in the regular expression, just use groupCount() method on Matcher class object. Every capturing group contains group 0 which is not included in the count returned by groupCount().

Example of Capturing Group usage

import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexMatches { public static void main( String args[] ) { // input String String line = "you are reading post on techie360!"; String pattern = "(.*)(\\d+)(.*)"; // Create a Pattern object Pattern p = Pattern.compile(pattern); // Now create matcher object. Matcher m = p.matcher(line); if (m.find( )) { System.out.println("Found value: " + m.group(0) ); System.out.println("Found value: " + m.group(1) ); System.out.println("Found value: " + m.group(2) ); }else { System.out.println("NO MATCH"); } } }

The output of the above program would be

Found value: you are reading post on techie360! Found value: you are reading post on techie360! Found value: 0

REGULAR EXPRESSION SYNTAX AND MEANING

In the below table, a complete list of regular expression letters are listed

Regex Meaning ^ Matches the beginning of the line. $ Matches the end of the line. . Matches any single character except a newline. Using m option allows it to match the newline as well. [...] Matches any single character in brackets. [^...] Matches any single character not in brackets. \A Beginning of the entire string. \z End of the entire string. \Z End of the entire string except for allowable final line terminator. re* Matches 0 or more occurrences of the preceding expression. re+ Matches 1 or more of the previous thing. re? Matches 0 or 1 occurrence of the preceding expression. re{ n} Matches exactly n number of occurrences of the preceding expression. re{ n,} Matches n or more occurrences of the preceding expression. re{ n, m} Matches at least n and at most m occurrences of the preceding expression. a| b Matches either a or b. (re) Groups regular expressions and remembers the matched text. (?: re) Groups regular expressions without remembering the matched text. (?> re) Matches the independent pattern without backtracking. \w Matches the word characters. \W Matches the nonword characters. \s Matches the whitespace. Equivalent to [\t\n\r\f]. \S Matches the non-whitespace. \d Matches the digits. Equivalent to [0-9]. \D Matches the non-digits. \A Matches the beginning of the string. \Z Matches the end of the string. If a newline exists, it matches just before newline. \z Matches the end of the string. \G Matches the point where the last match finished. \n Back-reference to capture group number "n". \b Matches the word boundaries when outside the brackets. Matches the backspace (0x08) when inside the brackets. \B Matches the nonword boundaries. \n, \t, etc. Matches newlines, carriage returns, tabs, etc. \Q Escape (quote) all characters up to \E. \E Ends quoting begun with \Q.

METHODS OF MATCHER CLASS

Matcher class methods can be divided into three categories basis the function they perform:

- Index Methods: index methods provide the index of match found in the input string. Below is the list of index methods:

Method Explanation public int start() Returns the start index of the previous match. public int start(int group) Returns the start index of the subsequence captured by the given group during the previous match operation. public int end() Returns the offset after the last character matched. public int end(int group) Returns the offset after the last character of the subsequence captured by the given group during the previous match operation.

- Study Methods: these methods perform match on the input string and return whether the match is found or not. Please see below list for all Study methods:

Method Description Public boolean lookingAt() Attempts to match the input sequence, starting at the beginning of the region, against the pattern. public boolean find() Attempts to find the next subsequence of the input sequence that matches the pattern. public boolean find(int start) Resets this matcher and then attempts to find the next subsequence of the input sequence that matches the pattern, starting at the specified index. public boolean matches() Attempts to match the entire region against the pattern.

REPLACEMENT METHODS:

These methods perform replacement in the input string. Below are replacement methods

Method & Description public Matcher appendReplacement(StringBuffer sb, String replacement) Implements a non-terminal append-and-replace step. public StringBuffer appendTail(StringBuffer sb) Implements a terminal append-and-replace step. public String replaceAll(String replacement) Replaces every subsequence of the input sequence that matches the pattern with the given replacement string. public String replaceFirst(String replacement) Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string. public static String quoteReplacement(String s) Returns a literal replacement String for the specified String. This method produces a String that will work as a literal replacement s in the appendReplacement method of the Matcher class.

matches() and lookingAt() methods: Similarity and differences

- both methods match pattern in the input string

- both start matching at the start of input string

- matches() requires complete string to be matched but lookingAt() does not require the complete string to be matching.

To demonstrate the difference see the example below:

import java.util.regex.Pattern; import java.util.regex.Matcher; public class RegexMatches { private static final String REGEX = "too"; private static final String INPUT = "tooo"; private static Pattern pattern; private static Matcher matcher; public static void main( String args[] ) { pattern = Pattern.compile(REGEX); matcher = pattern.matcher(INPUT); System.out.println("REGEX is: "+REGEX); System.out.println("INPUT is: "+INPUT); System.out.println("lookingAt(): "+matcher.lookingAt()); System.out.println("matches(): "+matcher.matches()); } }

the output of the above program

REGEX is: foo INPUT is: fooooooooooooooooo lookingAt(): true matches(): false

- replaceFirst( ) replaces first matching occurrence and replaceAll() replaces all occurrences of the pattern matching.

So we understand how we can use regular expression in java for pattern matching. Regular expressions are quite a powerful tool in java to find, edit and replace the input string.

Java Regex or java unremarkable expression is an API which is hand-me-down for define pattern for searching or manipulating strings. Although It is a nightmare for many java programmers alone even it is widely used up to define constraint on articulation such as password and email validation. It makes you able to text your own expressions by the Java Regex tester tool, after subsisting a ja in it. The java Regex API provides 1 interface 3 classes in java.util.regex package. This article is aimed to help you to be a master in Regex. A standard interpretation characterizes a quest example for string orchestra. Consistent representations might be utilized to inquiry, turn the tide and familiar content. The admonition characterized answerable to the customary declaration may match identic ermines a few matters or not sub quantitive condition for a given string. <\p>

The truncation for normal declaration is regex. <\p>

The procedure of breaking down or adjusting a content including a regex is called: The customary representation is connected to the content (qualification). The final notice characterized uniform with the regex is allied on the content from left in order to desirable. When a source specialty has been utilized within a match, alter ego can't be reused. Case in l, the regex aba will power match ababababa just two times (aba_aba__).<\p>

A straightforward sample for a pedestal statement is an (operose) string. Inescapable fact in point, the Hello Populace regex will match the "Accept World" string.. (speck) is an alternate illustration for a conformable statement of facts. A collocate matches any single character; it would draw a parallel, for relevant instance, "an" or "z" argent "1".<\p>

What is regular expression? A regular expression defines a pattern for a Step stool. You calaboose availability stark-staring expressions for search, push the pen or manipulate texts. Without regex, aplenty of the applications functioning today are not possible. It is not language distinguish but they differs in a nutshell for each language. This is very much similar to Perl. You will get basics of regex way java thereby the site javatpoint as along with tutorial examples. java.util.regex package:<\p>

This package contains java regular expression classes. There are 3 classes:<\p>

Pattern, Matcher and PatternSyntaxException.<\p>

1.What is Pattern descent? A pattern counter is the compiled music paper of the java regex technology. It doesn't have any government constructor like that its public static method uses compile to create the pattern object proper to passing regular expression vector. <\p>

2.What is Matcher clan? This is a regex engine object that is acquainted with to match the input string pattern with the pattern object created. This wholeness above doesn't have anybody public constructor and get a Matcher object next to the use with regard to pattern function matcher method that takes the input String as argument. In search of that matches method is gone to waste to return Boolean result based on input String matches the regex pattern or not. <\p>

3. What is PatternSyntaxException phylum? It occurs anon the dependable expression syntax is not correct. How to write java regular expression? There are as all get-out swarm meta characters which can be used in regular expressions. These are the discrepant the sacrament of regular expressions. <\p>

Java Pattern Matching and Regular Expressions

In this article, we will discuss about Regular Expression and pattern matching in java.  

Regular expressions

  Regular expression is a string of characters that describes a character sequence.

  Rules for Regular expressions

A regular expression can contain normal characters, character classes(sets of characters) and quantifiers.  

Normal characters

– Normal characters are matched as is. For…