Often unknown, or heralded as confusing, regular expressions have defined the standard for powerful text manipulation and search. Without them, many of the applications we know today would not function. This two-part series explores the basics of regular expressions in Java, and provides tutorial examples in the hopes of spreading love for our pattern-matching friends. (Read part one.)

Part 2: Look-ahead & Configuration flags

Have you ever wanted to find something in a string, but you only wanted to find it when it came before another pattern in that string? Or maybe you wanted to find a piece of text that was not followed by another piece of text? Normally, with standard string searching, you would have to write a somewhat complex function to perform the exact operation you wanted. This can, however, all be done on one line using regular expressions. This chapter will also cover the configuration flags available to modify some of the behaviors of the regular expression patterns language.

This article is part two in the series: “[[Regular Expressions]].” Read part one for more information on basic matching, grouping, extracting, and substitution.

1. Look-ahead & Look-behind

Look-ahead and look-behind operations use syntax that could be confused with grouping (See Ch. 1 – Basic Grouping,) but these patterns do not capture values; therefore, using these constructs, no values will be stored for later retrieval, and they do not affect group numbering. Look-ahead operations look forward, starting from their location in the pattern, continuing to the end of the input. Look-behind expressions do not search backwards, but instead start at the beginning of the pattern and continue up to/until the look-behind expression. E.g.: The statement “my dog is (?!(green|red))\\w+” asserts that ‘green’ will not the word to the look-ahead’s direct right. In other words: My dog is not green or red, but my dog is blue.

Look-ahead/behind constructs (non-capturing)

So what does this all mean? What does a look-ahead really do for me? Say, for example, we wanted to know if our input string contains the word “incident” but that the word “theft” should not be found anywhere. We can use a negative look-ahead to ensure that there are no occurrences.

“(?!.*theft).*incident.*”

This expression exhibits the following behavior: A more complex example is password validation. Let’s say we want to ensure that a password is made at least 8, but at most 12 alphanumeric characters, and at least two numbers, in any position. We will need to use a look-ahead expression in order to enforce a requirement of two numbers. This look-ahead expression will require any number of characters to be followed by a single digit, followed by any number of characters, and another single digit. E.g.: …4…2, or …42, or 42…, or 4…2.

1.1. Example

This produces the following output:

password: does not match p4ssword: does not match p4ssw0rd: matches p45sword: matches

Dissecting the pattern:

"^(?=.*[0-9].*[0-9])[0-9a-zA-Z]{8,12}$"

Multiple look-ahead operations do not evaluate in a specific order. They must all be satisfied equally, and if they logically contradict each other, the pattern will never match.

---

Visual Regex Tester

To get a more visual look into how regular expressions work, try our visual java regex tester.

---

2. Configuring the Matching Engine

Pattern configuration flags for Java appear very similar to look-ahead operations. Flags are used to configure case sensitivity, multi-line matching, and more. Flags can be specified in collections, or as individual statements. Again, these expressions are not literal, and do not capture values.

2.1. Configuration flags

2.2. Case insensitivity mode

2.3. UNIX lines mode

2.4. Multi-line mode

2.5. Dot-all mode

2.6. Unicode-case mode

2.7. Comments mode

2.8. Examples

2.8.1. Global toggle

In order to toggle flags for the entire expression, the statement must be at the head of the expression. The above expression will ignore case, and will set the dot ‘.’ character to include newlines.

2.8.2. Local toggle

In order to toggle flags for the a single non-capturing group, the group must adhere to the following syntax The above expression will ignore case within the group, but adhere to case beyond.

2.8.3. Applied in Java

This produces the following output:

Control result was: false Case insensitive result was: false Dot-all result was: false Configured result was: true

Dissecting the pattern:

We had to enable multi-line and case-insensitive modes for our pattern to match. The look-ahead in this example is very similar to the pattern itself, and in this case, the pattern could be substituted for another look-ahead. Because we don’t care in which order we find these two items, the way this is written, substituting “(?=.*Blue.*)” for “.*Blue.*” would be an acceptable change; however, if we did care in which order we wanted to find these colors, we would need to be more precise with our ordering. If we wanted to ensure that the ‘Green’ came after ‘Blue’ we would need to move the look-ahead as seen below, and so on.

3. Conclusion

Regular expressions provide an extremely flexible and powerful text processing system. Try to imagine doing this work using String.substring(…) or String.indexOf(…), with loops, nested loops, and dozens of if statements. I don’t even want to try… so play around! Think about using regular expressions next time you find yourself doing text or pattern manipulation with looping and other painful methods. Let us know how you do.

This article is part two in the series: “Guide to Regular Expressions in Java.” Read part one for more information on basic matching, grouping, extracting, and substitution.