What is a lookaround assertion in a Java regular expression, and what does "zero-width" mean?
answer
- Cursor sits between chars; consume = advance + include
- Zero-width = checks condition, moves nothing, adds nothing to match
- Four kinds: (?=) (?!) (?<=) (?<!)
- Lookahead asserts what FOLLOWS; lookbehind what PRECEDES
- Not capturing groups - no group(n)
basics
~20 sA lookaround is a regex condition that checks whether text around the current spot matches a pattern, without including that text in the match. "Zero-width" means it consumes no characters - the position does not move.
solid answer
~40 sA lookaround assertion is a regex construct that tests whether a sub-pattern matches at the current position, but does not add those characters to the matched text. It is "zero-width" because the regex engine's cursor stays put: nothing is consumed. There are four kinds - positive lookahead (?=X) requires X to follow, negative lookahead (?!X) requires X not to follow, positive lookbehind (?<=X) requires X to precede, and negative lookbehind (?<!X) requires X not to precede. They are used to assert context (e.g. a digit only if a letter follows) without capturing that context, which keeps matches and replacements clean. In Java you write them inside Pattern/Matcher just like any other group.
code
java · 6 linesimport java.util.regex.*;
Matcher m = Pattern.compile("\\d(?=px)").matcher("5px 9em 7px");
while (m.find()) {
System.out.println(m.group()); // prints 5 then 7 (digits followed by px); 9 is skipped
}go deeper
Can define zero-width and name the four lookarounds, and explain that the asserted text is not consumed.
Can pick the right lookaround for a given context-sensitive match and explain why it keeps group(0) clean.
Can reason about cursor mechanics, combine multiple lookarounds at one position, and explain replacement behavior.
Can weigh lookaround readability/performance against alternatives (captured-group rebuild, split, parser) and set team conventions.
## First principles: how a regex engine moves When a regular-expression engine matches text, imagine a **cursor** sitting between characters. As the engine matches ordinary characters like `a` or `\d`, it **consumes** them: the cursor moves forward and those characters become part of the matched substring. "Consuming" simply means "this character is now part of what we matched, advance past it." ## What "zero-width" means A **zero-width** construct is one that checks a condition at the cursor's current position **without moving the cursor and without adding any character to the match**. The width of the thing it matches is zero. Familiar zero-width constructs you may already know are `^` (start of line) and `$` (end of line) - they assert a position, they don't eat a character. A **lookaround assertion** is a zero-width construct that lets you assert *an entire sub-pattern* matches (or fails to match) just before or just after the cursor, while still consuming nothing. ## The four lookarounds - **Positive lookahead** `(?=X)` - succeeds if pattern `X` matches starting at the current position. The cursor does **not** advance. - **Negative lookahead** `(?!X)` - succeeds if pattern `X` does **not** match at the current position. - **Positive lookbehind** `(?<=X)` - succeeds if pattern `X` matches the text **immediately ending** at the current position (i.e. just behind the cursor). - **Negative lookbehind** `(?<!X)` - succeeds if `X` does **not** match immediately behind the cursor. ## Why this is useful Because lookarounds consume nothing, the characters they test are **not part of `group(0)`** (the matched text). This matters most in two cases: 1. **Replacement** - `replaceAll` only replaces the consumed text. If you assert context with a lookaround, that context survives the replacement. Example: insert a comma between digit groups without deleting any digit. 2. **Tokenizing/validation** - you can require surrounding context ("a word only when followed by a colon") without capturing it. ## A concrete trace Pattern `\d(?=px)` against `5px`: 1. Engine matches `\d` -> matches `5`, cursor now sits after `5`. 2. Engine reaches `(?=px)`. It tries to match `px` from the current position **without moving**. The next chars are `px` -> success. Cursor stays after `5`. 3. Overall match succeeds, `group(0)` is `"5"` only - the `px` was looked at but not consumed. Contrast with `\dpx` (no lookahead): that would match `"5px"` entirely. ## Java specifics Java's `java.util.regex` supports all four lookarounds. You use them inside any `Pattern`. Lookarounds are **not capturing groups** - they never create a `group(n)`. (A normal `(...)` captures; the `(?...)` family are special non-capturing constructs.) One important Java restriction: **lookbehind must be bounded in length** - more on that in the dedicated question.
- Does a lookahead create a capturing group you can read with group(1)?No. Lookarounds are special non-capturing constructs. If you need to capture text you must put a real (...) group inside or around them.
- Name a zero-width construct other than a lookaround.Anchors like ^, $, \b (word boundary), \A, \z - they assert a position without consuming a character.
saying these in an interview costs you the question
- Thinking the looked-at text becomes part of group(0) or gets replaced
- Confusing lookaround with a capturing group
- Believing lookahead moves the cursor forward past the asserted text