Regular expressions in programming

public static String checkRegularExpression(String regex, String text) {
    try {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        StringBuilder findResult = new StringBuilder();

        // Try to match all text to a pattern
        boolean isMatching = matcher.matches();
        findResult.append("\nmatches(): All text").append(isMatching ? " " : " NOT ").append("matches the pattern.");

        // Restoring the original position of the matcher
        matcher.reset();

        // Searching for all strings in the given text using a loop
        boolean found = matcher.find();
        if (!found)
            findResult.append("\nnfind(): There is no matching string");
        else
            do {
                findResult.append(String.format("\nfind(): Found substring: '%s' between chars in position: %d and %d",
                        matcher.group(), matcher.start(), matcher.end()));
            } while(matcher.find());

        return findResult.toString();
    } catch (Exception ex) {
        return String.format("Error has occurred %s", ex.getMessage());
    }
}

Literals

The literals used in the regular expression are matched sequentially.

public static void main(String... args) {
    String regexp = "oskar";
    String text = "this is oskar. oskar is here";

    String result = checkRegularExpression(regexp, text);
    System.out.println(result);
}

matches(): All text NOT matches the pattern.
find(): Found substring: 'oskar' between chars in positions: 8 and 13
find(): Found substring: 'oskar' between chars in positions: 15 and 20

String regexp = "o*";
String text = "oooxooxooo";
String result = checkRegularExpression(regexp, text);

matches(): All text NOT matches the pattern. 
find(): Found substring: 'ooo' between chars in positions: 0 and 3
find(): Found substring: '' between chars in positions: 3 and 3
find(): Found substring: 'oo' between chars in positions: 4 and 6
find(): Found substring: '' between chars in positions: 6 and 6
find(): Found substring: 'ooo' between chars in positions: 7 and 10
find(): Found substring: '' between chars in positions: 10 and 10

public static void main(String... args) {
    String regexp = "(x";
    String text = "this is text with brackets (x)";

    String result = checkRegularExpression(regexp, text);
    System.out.println(result);
}

Error has occurred Unclosed group near index 2
(x

public static void main(String... args) {
    String regexp = "dj|man|you";
    String text = "This id good man - great dj.";

    String result = checkRegularExpression(regexp, text);
    System.out.println(result);
}

matches(): All text NOT matches the pattern.
find(): Found substring: 'man' between chars in positions: 13 and 16
find(): Found substring: 'dj' between chars in positions: 25 and 27

Character classes

By using square brackets, we can introduce the so-called character classes. A simple character class is a string of characters enclosed in square brackets, e.g.

[123abc]

The matcher will match any of the characters listed in this pattern. It is in fact an abbreviation of 1 | 2 | 3 | a | b | c.

If the first character in square brackets is ^, a match will be made for any character except those listed. This is a kind of negation of the character class. For example, any character except x, y, and z will match [^ xyz].

It is also possible to formulate ranges of characters (which makes writing much easier). When formulating ranges, we use the natural symbol -.

Sample patterns:
[0-9] – any digit,
[a-zA-Z] – any lowercase and uppercase letter of the English alphabet.
[a-zA-Z0-9] = any number or letter

Example X
The word Oskar should be followed by a space, then one of the numbers 1,2,3,7,8,9, then any number, a slash and any character except the numbers 0,1,2,3 and lowercase letters of the English alphabet. Character class specifies one character belonging (or not) to the specified set in square brackets. The order of the characters in the set is not important, but the ranges must be in ascending order.

public static void main(String... args) {
    String regexp = "Oskar [1-37-9][0-9]/[^0-3a-z]";
    String text = "Oskar 11/9";

    String result = checkRegularExpression(regexp, text);
    System.out.println(result);
}

matches(): All text matches the pattern. 
find(): Found substring: 'Oskar 11/9' between chars in positions: 0 and 10

Example X

public static void main(String... args) {
    String regexp = "Oskar [1-37-9][0-9]/[^0-3a-z]";
    String text = "Oskar 51/9";

    String result = checkRegularExpression(regexp, text);
    System.out.println(result);
}

matches(): All text NOT matches the pattern. 
find(): There is no matching string

Example X
Pattern that matches texts that consist of two arbitrary digits, followed by two arbitrary characters, and three non-numeric characters.

public static void main(String... args) {
    String regexp = "\\d\\d..\\D\\D\\D";
    String text = "12##aa$";

    String result = checkRegularExpression(regexp, text);
    System.out.println(result);
    }

matches(): All text matches the pattern. 
find(): Found substring: '12##aa$' between chars in positions: 0 and 7

Character classes (which, after all, are treated as sets) can also be combined in an even more flexible way. The following operations are available for this:

Common part of classes (sets)

Obtained by the operator &&. The common part of classes defines the characters that appear in both classes. For example, the pattern: [1-9 && 3-7] matches the digits 3, 4, 5, 6, 7 which are common to both of the ranges listed. We could write the same pattern anyway [1-9 && [3-7]].

String regexp = "[a-z && [^ mno]]";
String text = "x";
String result = checkRegularExpression(regexp, text);

matches(): All text matches the pattern. 
find(): Found substring: 'x' between chars in positions: 0 and 1

String regexp = "[a-z && [^ mno]]";
String text = "n";
checkRegularExpression(regexp, text);

matches(): All text NOT matches the pattern. 
find(): There is no matching string

Well, the metacharacters used in the class character set (in square brackets) (except for the backslash, the symbol ^, and -) lose their special meaning and are treated literally. In particular, a period is treated literally (it stands for any character outside of the square brackets). You can see what’s going on on the fragment code below:

Example X

String regexp = "[({]x[})]";
String text = "{x}";
checkRegularExpression(regexp, text);

matches(): All text matches the pattern. 
find(): Found substring: '{x}' between chars in positions: 0 and 3

The „escape” (backslash) symbol allows you to indicate that you want to treat the square bracket literally. (and we normally only use it for class).

String regexp = "[\[({]x[)}\]]";
String text = "[x]";
checkRegularExpression(regexp, text);

matches(): All text matches the pattern. 
find(): Found substring: '[x]' between chars in positions: 0 and 3

String regexp = "(dj|singer|song)+";
String text = "djsongsinger";
checkRegularExpression(regexp, text);

matches(): All text matches the pattern. 
find(): Found substring: 'djsongsinger' between chars in positions: 0 and 12

Example X
Pattern describes situation when the text may consist of any single word dj, singer, song (without the trailing space) and that this text may consist of any number of repetitions of these words, but separated by at least one and no more than three spaces.

So, the text begins with one of the words dj, singer, song followed by zero or more repetitions (* quantifier) of the text described by the expression in second parentheses. The expression in the second parentheses states that the text they describe is to start with 1, 2, or three spaces (quantifier {1,3}), followed by one of the words dj, singer, song.

String regexp = "(dj|singer|song)( {1,3}(dj|singer|song))*";
String text = "dj dj song song";
checkRegularExpression(regexp, text);

String regexp2 = "(dj|singer|song)({1,3}(dj|singer|song))*";
String text2 = "dj  dj   dj  dj";
checkRegularExpression(regexp2, text2);

matches(): All text NOT matches the pattern. 
find(): Found substring: 'dj' between chars in positions: 0 and 2
find(): Found substring: 'dj' between chars in positions: 3 and 5
find(): Found substring: 'song' between chars in positions: 6 and 10
find(): Found substring: 'song' between chars in positions: 11 and 15

matches(): All text NOT matches the pattern. 
find(): Found substring: 'dj' between chars in positions: 0 and 2
find(): Found substring: 'dj' between chars in positions: 4 and 6
find(): Found substring: 'dj' between chars in positions: 9 and 11
find(): Found substring: 'dj' between chars in positions: 13 and 15

Example X
Now let’s pay special attention to the use of parentheses. It is used not only to apply quantifiers, but also to change the order in which a regular expression is interpreted. If the first alternative dj | singer | song were not included in brackets, the interpretation of the expression (dj | singer | song)({1,3}(dj | singer | song))* would be:

either a dj or a singer or a song followed by 0 or more repetitions of dj, singer, song combinations, separated by spaces (from one to three). So we would get different than expected results. Only correct if text containing more than one word would start with „song„

String regexp = "dj|singer|song( {1,3}(dj|singer|song))*";
String text = "dj song";
checkRegularExpression(regexp, text);

String regexp2 = "(dj|singer|song)( {1,3}(dj|singer|song))*";
String text2 = "song dj song";
checkRegularExpression(regexp2, text2);

matches(): All text NOT matches the pattern. 
find(): Found substring: 'dj' between chars in positions: 0 and 2
find(): Found substring: 'singer' between chars in positions: 3 and 9

matches(): All text matches the pattern. 
find(): Found substring: 'song dj song' between chars in positions: 0 and 12

The quantifiers described so far are the so-called greedy quantifiers. The matcher – when used – is „greedy” because it first consumes all the input text (and tries to match it). If it fails, it backsits character by character until it is matched or not matched.

There are also two other kinds of quantifiers in Java: reluctant and possessive. Reluctant quantifiers – unlike greedy quantifiers – start at the beginning of the input text and take character by character looking for a match. Any attempt to match the entire text occurs at the very end.

Possessive quantifiers, like greedy ones, consume the entire text and check for a match, but when no match is found – unlike greedy quantifiers – there is no character-by-character backspace.

Example X

The example shows the difference in how the three types of quantifiers work.

// greedy quantifier
String regexp = ".*dj";
String text = "This is dj and techno is playing by this dj";
String result = checkRegularExpression(regexp, text);

// reluctant quantifier
regexp = ".*?dj";
text = "This is dj and techno is playing by this dj";
result = checkRegularExpression(regexp, text);

// possessive quantifier
regexp = ".+dj";
text = "This is dj and techno is playing by this dj";
result = checkRegularExpression(regexp, text);

matches(): All text matches the pattern. 
find(): Found substring: 'This is dj and techno is playing by this dj' between chars in positions: 0 and 43

matches(): All text matches the pattern. 
find(): Found substring: 'This is dj' between chars in positions: 0 and 10
find(): Found substring: ' and techno is playing by this dj' between chars in positions: 10 and 43

matches(): All text matches the pattern. 
find(): Found substring: 'This is dj and techno is playing by this dj' between chars in positions: 0 and 43

The greedy quantifier (first case) consumed the entire text, then the matcher backed off until it found a match (the words „dj” at the end). At this, the matcher has finished, as you can clearly see from the result of the find() method.

The reluctant quantifier (the second case) started from the beginning of the text, and the find() method had the opportunity to find two matches in the text in the pattern.

The possessive quantifier (third case) consumed the entire text, and there was nothing left to match the word „dj” in the pattern. This quantifier does not allow the matcher to fall back, so we got a mismatch.

Which type of quantifier to choose depends on the context.

Boundary matchers (anchors)

If we are interested in matching the pattern in a specific place of the text, we use the so-called boundary matchers otherwise known as „anchors”. In particular, we may want the match to occur at the beginning or end of a line, or at a word boundary. The symbols for marking the boundaries are as follows:

• ^ – beginning of line
• $ – end of line
• \b – on the verge of the word
• \B – not on verge of a word
• \A – start of entry
• \G – end of previous match
• \Z – end of input (without terminator)
• \z – end of input

Example X

The example is for matching lines that start with one or more digits. Assuming this regex is inside a Java String literal, you need to escape the backslashes for your \d and \w tags. Note the difference: the pattern „\d+.*” (Without specifying that the digits are at the beginning of the line) will allow find() to match part of the string „dj 567”:

String regexp = "^\\d+.*";
String text = "6789";
String result = checkRegularExpression(regexp, text);

regexp = "^\\d+.*";
text = "DJ 567";
result = checkRegularExpression(regexp, text);

regexp = "\\d+.*";
text = "DJ 567";
result = checkRegularExpression(regexp, text);

matches(): All text matches the pattern. 
find(): Found substring: '6789' between chars in positions: 0 and 4

matches(): All text NOT matches the pattern. 
find(): There is no matching string

matches(): All text NOT matches the pattern. 
find(): Found substring: '567' between chars in positions: 3 and 6

Example X

Now we will check if the line contains an integer at the very end (and extract it in a group).

String regexp = ".+?(\\d+)$";
String text = "this is dj 33";
String result = checkRegularExpression(regexp, text);

matches(): All text matches the pattern. 
find(): Found substring: 'this is dj 33' between chars in positions: 0 and 13

Example X

If we want to find only the whole „prod” words we will use the symbols \b.

String regexp = "\\bprod\\b";
String text = "prod producer production product prod unproductive";
String result = checkRegularExpression(regexp, text);

matches(): All text NOT matches the pattern. 
find(): Found substring: 'prod' between chars in positions: 0 and 4
find(): Found substring: 'prod' between chars in positions: 33 and 37

Example X

If we want to find the string „prod„, starting a word (which may be, but not necessarily a word) we would write:

String regexp = "\\bprod";
String text = "prod unprod producer production product prod unproductive";
String result = checkRegularExpression(regexp, text);

matches(): All text NOT matches the pattern. 
find(): Found substring: 'prod' between chars in positions: 0 and 4
find(): Found substring: 'prod' between chars in positions: 12 and 16
find(): Found substring: 'prod' between chars in positions: 21 and 25
find(): Found substring: 'prod' between chars in positions: 32 and 36
find(): Found substring: 'prod' between chars in positions: 40 and 44

Thank you for making it to the end of the article. If you have any comments or want to share your opinion about my work, write everything in the comments! See you next time! It’s time to code ! 🙂