Conditional Matching with Lookaheads

Introduction

Welcome back to Regex Validation, Flags, and Text Processing in Java! You've now completed two lessons, and your regex skills are growing impressively. In the first lesson, you learned to validate complete inputs with Pattern.matches(), creating username and password validators that check every character from start to finish. In the previous lesson, you mastered regex flags to control pattern behavior: writing readable, verbose patterns with comments, performing case-insensitive searches, handling line boundaries with Pattern.MULTILINE, and matching across newlines with Pattern.DOTALL . These tools give you tremendous flexibility in how patterns process text. However, there's another challenge that neither validation rules nor flags directly solve: what if you need to match text based on what comes before or after it, but without including that context in the match itself? Imagine extracting dollar amounts, but only when they're followed by the word "USD"; or finding passwords in a configuration file, but excluding any marked as "REDACTED"; or validating that a password contains both uppercase and lowercase letters without caring about their order. These scenarios require checking conditions without consuming the characters being checked. This lesson introduces lookaheads : powerful assertions that let you peek ahead in the text to verify conditions without including those characters in your match. Let's explore how lookaheads enable sophisticated conditional matching.

Understanding Lookaheads and Zero-Width Assertions

Lookaheads are a type of zero-width assertion: they check whether a pattern exists at a specific position without actually consuming any characters. Think of them as looking ahead in the text to verify something is there, then stepping back to continue matching from where you were. This "look but don't consume" behavior is fundamentally different from normal pattern matching, where the regex engine advances through the string as it matches each component. There are two types of lookaheads in Java's regex engine: Positive lookaheads (?=...) succeed if the pattern inside matches at the current position, but they don't advance the matching position. Negative lookaheads (?!...) succeed if the pattern inside does not match at the current position, again without consuming characters. Consider extracting prices from text where some are in USD and others in EUR. A normal pattern like "\\d+\\.\\d{2} USD" would match "12.50 USD," but it includes " USD" in the captured result. With a positive lookahead "\\d+\\.\\d{2}(?=\\s*USD)", you match the price only if it's followed by " USD," but the lookahead doesn't consume " USD," so your match contains just the numeric amount. Similarly, negative lookaheads let you exclude matches based on what follows. These assertions become especially powerful for validation, where you need to ensure certain characters exist somewhere in the string without caring about their exact position.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Positive Lookaheads for Context-Aware Matching

Let's explore positive lookaheads through a practical example: extracting prices from text, but only when they're followed by "USD." We want the numeric amounts themselves, not the currency label. A positive lookahead lets us specify this condition precisely.

Java

import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;
import java.util.List;

public static List<String> extractPricesWithCurrency(String text) {
    // Match amounts only when followed by USD (not consumed)
    Pattern p = Pattern.compile("\\d+(?:\\.\\d{2})?(?=\\s*USD)");
    Matcher m = p.matcher(text);
    List<String> prices = new ArrayList<>();
    while (m.find()) {
        prices.add(m.group());
    }
    return prices;
}

import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;
import java.util.List;

public static List<String> extractPricesWithCurrency(String text) {
    // Match amounts only when followed by USD (not consumed)
    Pattern p = Pattern.compile("\\d+(?:\\.\\d{2})?(?=\\s*USD)");
    Matcher m = p.matcher(text);
    List<String> prices = new ArrayList<>();
    while (m.find()) {
        prices.add(m.group());
    }
    return prices;
}

This pattern breaks down into three key components:

\\d+ matches one or more digits for the dollar amount.
(?:\\.\\d{2})? optionally matches a decimal point followed by exactly two digits; the (?:...) creates a non-capturing group so we can apply ? to the entire decimal portion.
(?=\\s*USD) is our positive lookahead, checking that optional whitespace and "USD" follow the number, but without including them in the match.

The lookahead (?=\\s*USD) ensures we only capture prices that have "USD" after them. The pattern \\s* allows for zero or more spaces between the amount and "USD," handling both "12.50USD" and "12.50 USD." Crucially, the lookahead doesn't consume "USD" or the whitespace, so if multiple prices appear consecutively, we can match them all without the currency label interfering with subsequent matches.

Combining Multiple Lookaheads for Validation

Lookaheads become even more powerful when combined. Each lookahead can check a different condition, and all must succeed for the overall pattern to match. This technique is particularly useful for validation, where you need to ensure multiple requirements are met without caring about the order in which they appear. Let's validate passwords that must contain at least one lowercase letter, at least one uppercase letter, and at least one digit, with a minimum length of eight characters.

Java

public static boolean validateStrongPassword(String p) {
    // Use lookaheads to require at least one lowercase, uppercase, and digit; min length 8
    // Each (?=...) assertion checks the entire string without consuming characters
    return Pattern.matches("(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}", p);
}

public static boolean validateStrongPassword(String p) {
    // Use lookaheads to require at least one lowercase, uppercase, and digit; min length 8
    // Each (?=...) assertion checks the entire string without consuming characters
    return Pattern.matches("(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}", p);
}

This pattern employs three positive lookaheads in sequence:

(?=.*[a-z]) checks that somewhere in the string there's at least one lowercase letter; the .* matches any characters leading up to it.
(?=.*[A-Z]) similarly checks for at least one uppercase letter anywhere in the string.
(?=.*\\d) ensures at least one digit appears somewhere.
.{8,} finally matches the actual password, requiring at least eight characters of any type.

The beauty of this approach is that each lookahead starts from the same position at the beginning of the string and scans forward independently. Because lookaheads are zero-width assertions, they do not consume any characters. Once a lookahead finishes its check, the regex engine "resets" its position back to where it started before moving to the next part of the pattern. This allows all three lookaheads to verify their conditions against the entire string regardless of where those characters appear. After all lookaheads succeed, the .{8,} does the actual matching and character consumption to ensure sufficient length. This pattern would reject "Password" (no digit), "password1" (no uppercase), "PASSWORD1" (no lowercase), and "Pass1" (too short), while accepting "Password1" or "StrongP4ss."

Introduction

Understanding Lookaheads and Zero-Width Assertions

Join the 1M+ learners on CodeSignal

Positive Lookaheads for Context-Aware Matching

Testing Price Extraction with Lookaheads

Negative Lookaheads to Exclude Patterns

Testing Password Extraction

Combining Multiple Lookaheads for Validation

Testing Strong Password Validation

Conclusion and Next Steps