How do you combine multiple Pattern flags in Java, and how does combining compile-time flags compare to combining inline flags? Give the bitwise mechanism.

Compile flags = bits → combine with | (bitwise OR)
Inline = concatenate letters, e.g. (?ims)
Each constant is a distinct power-of-two bit
LITERAL / CANON_EQ have no inline letter
p.flags() returns the combined int

basics

~10 s

Combine compile-time flags with the bitwise OR operator |, e.g. Pattern.CASE_INSENSITIVE | Pattern.MULTILINE. Inline, just list the letters together, e.g. (?im). Both ways enable several flags at once.

solid answer

~50 s

Compile-time flags are integer bit constants, so you combine them with the bitwise OR '|': Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.DOTALL | Pattern.MULTILINE). Each constant is a distinct power-of-two bit; OR-ing merges them into one int the compiler reads. Inline, you concatenate the flag letters inside one token: (?imsd) enables CASE_INSENSITIVE, MULTILINE, DOTALL and UNIX_LINES at once, and you can scope them with (?ims:...) or turn some off with (?i-m:...). The two approaches are equivalent for the flags that have inline letters; combining compile flags with | is the idiomatic choice when the pattern is a fixed string in code, while inline combos are needed when the pattern text carries its own modes (config-driven) or when you need per-segment scoping. A subtle point: a few constants (e.g. LITERAL, CANON_EQ) have no inline letter and can only be set as compile flags.

code

java · 18 lines

java

import java.util.regex.*;

// Compile-time: OR the bit constants
int flags = Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL;
Pattern p = Pattern.compile("^a.*b$", flags);
System.out.println(p.flags() == flags); // true

// Inline equivalent: concatenate letters
Pattern q = Pattern.compile("(?ims)^a.*b$");

String text = "A1\nz\nB2";
System.out.println(p.matcher(text).find()); // true (case-insensitive, multiline, dot crosses lines)
System.out.println(q.matcher(text).find()); // true

// LITERAL has no inline letter — compile flag only
Pattern lit = Pattern.compile("a.b", Pattern.LITERAL);
System.out.println(lit.matcher("a.b").matches()); // true: '.' is literal
System.out.println(lit.matcher("axb").matches()); // false

for a junior

Knows you can pass more than one flag and that inline letters can be listed together.

for a middle

Correctly uses | for compile flags and concatenated letters inline; knows they're equivalent for letter-backed flags.

for a senior

Explains the power-of-two bitmask mechanism, p.flags(), and that LITERAL/CANON_EQ are compile-only; chooses inline vs compile deliberately.

for a principal

Reasons about flag provenance in dynamically composed/generated patterns, the security implications of accepting inline flags from untrusted input, and API design for exposing regex options to callers.

Compile flags are bit masks

The Pattern flag constants are public static final int values, each a single distinct bit (a power of two): UNIX_LINES=0x01, CASE_INSENSITIVE=0x02, COMMENTS=0x04, MULTILINE=0x08, LITERAL=0x10, DOTALL=0x20, UNICODE_CASE=0x40, CANON_EQ=0x80, UNICODE_CHARACTER_CLASS=0x100. Because no two share a bit, you merge them with the bitwise OR operator |:

java

int flags = Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL;
Pattern p = Pattern.compile(regex, flags);

The single resulting int has one bit set per requested flag; the compiler inspects each bit. (You should never hardcode the hex values — use the named constants; the numbers are shown only to explain the mechanism.) You can later inspect what was set via p.flags(), which returns that same int.

Inline flags concatenate

Inline, you don't OR anything — you just list the letters in one token. (?im) = CASE_INSENSITIVE + MULTILINE. (?ims) adds DOTALL. The letters and their constants:

i → CASE_INSENSITIVE
m → MULTILINE
s → DOTALL
x → COMMENTS
u → UNICODE_CASE
d → UNIX_LINES
U → UNICODE_CHARACTER_CLASS

You can scope a combo to a group — (?ims:...) — and mix on/off — (?im-s:...) turns i and m on, s off.

Equivalence and when to use which

For any flag that has an inline letter, the compile-flag form and the inline form are equivalent. Choose based on context:

Compile flags + |: the pattern is a literal in your Java code; this keeps the mode visible at the call site and applies to the whole pattern.
Inline combos: the pattern text comes from outside (config/db/user) where you can't pass Java flags, or you need per-segment scoping that a whole-pattern compile flag can't express.

Flags with no inline letter

A few flags exist only as compile constants and have no inline equivalent: notably Pattern.LITERAL (treat the whole pattern as literal text), Pattern.CANON_EQ (canonical equivalence of Unicode), and combining them must be done in the flags int. If you need those, you must use the compile-time API.

Pitfalls

Using + or || instead of | — || is logical-OR on booleans and won't compile here; + happens to work numerically only because the bits don't overlap, but it's wrong intent and breaks if a bit is ever set twice. Always use |.
Repeating a flag both as a compile flag and inline is harmless (same bit) but noisy.
Forgetting that scoped inline combos revert after their group, while a compile flag is global.

Deriving the answer

Need several whole-pattern modes from code? OR the constants with |. Pattern text owns its modes, or you need scoping? Concatenate letters inline, optionally scoped. Need LITERAL/CANON_EQ? Compile flags only.

## Compile flags are bit masks The `Pattern` flag constants are `public static final int` values, each a **single distinct bit** (a power of two): `UNIX_LINES=0x01`, `CASE_INSENSITIVE=0x02`, `COMMENTS=0x04`, `MULTILINE=0x08`, `LITERAL=0x10`, `DOTALL=0x20`, `UNICODE_CASE=0x40`, `CANON_EQ=0x80`, `UNICODE_CHARACTER_CLASS=0x100`. Because no two share a bit, you merge them with the **bitwise OR** operator `|`: ```java int flags = Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL; Pattern p = Pattern.compile(regex, flags); ``` The single resulting `int` has one bit set per requested flag; the compiler inspects each bit. (You should never hardcode the hex values — use the named constants; the numbers are shown only to explain the mechanism.) You can later inspect what was set via `p.flags()`, which returns that same int. ## Inline flags concatenate Inline, you don't OR anything — you just **list the letters** in one token. `(?im)` = CASE_INSENSITIVE + MULTILINE. `(?ims)` adds DOTALL. The letters and their constants: - `i` → CASE_INSENSITIVE - `m` → MULTILINE - `s` → DOTALL - `x` → COMMENTS - `u` → UNICODE_CASE - `d` → UNIX_LINES - `U` → UNICODE_CHARACTER_CLASS You can scope a combo to a group — `(?ims:...)` — and mix on/off — `(?im-s:...)` turns i and m on, s off. ## Equivalence and when to use which For any flag that has an inline letter, the compile-flag form and the inline form are **equivalent**. Choose based on context: - **Compile flags + `|`**: the pattern is a literal in your Java code; this keeps the mode visible at the call site and applies to the whole pattern. - **Inline combos**: the pattern text comes from outside (config/db/user) where you can't pass Java flags, or you need **per-segment** scoping that a whole-pattern compile flag can't express. ## Flags with no inline letter A few flags exist **only** as compile constants and have no inline equivalent: notably `Pattern.LITERAL` (treat the whole pattern as literal text), `Pattern.CANON_EQ` (canonical equivalence of Unicode), and combining them must be done in the `flags` int. If you need those, you must use the compile-time API. ## Pitfalls - Using `+` or `||` instead of `|` — `||` is logical-OR on booleans and won't compile here; `+` happens to work numerically only because the bits don't overlap, but it's wrong intent and breaks if a bit is ever set twice. Always use `|`. - Repeating a flag both as a compile flag and inline is harmless (same bit) but noisy. - Forgetting that scoped inline combos revert after their group, while a compile flag is global. ## Deriving the answer Need several whole-pattern modes from code? OR the constants with `|`. Pattern text owns its modes, or you need scoping? Concatenate letters inline, optionally scoped. Need LITERAL/CANON_EQ? Compile flags only.

Why is Pattern.CASE_INSENSITIVE | Pattern.DOTALL preferred over Pattern.CASE_INSENSITIVE + Pattern.DOTALL?
| expresses 'set these bits' and is correct even if a value were ever non-distinct; + is arithmetic and only coincidentally works because the bits don't overlap. Use | for clarity and safety.
You need LITERAL mode plus case-insensitivity from a config-supplied pattern string. Any catch?
LITERAL has no inline letter, so you can't express it in the string; you must pass Pattern.LITERAL (and CASE_INSENSITIVE) as compile flags — but note LITERAL makes the whole pattern literal, so inline (?i) inside it wouldn't be interpreted either.

saying these in an interview costs you the question

Using || (logical OR) instead of | to combine flags
Assuming every compile flag has an inline letter (LITERAL/CANON_EQ don't)
Thinking you must call compile multiple times to apply multiple flags
Hardcoding the numeric bit values instead of named constants

How do you combine multiple Pattern flags in Java, and how does combining compile-time flags compare to combining inline flags? Give the bitwise mechanism.

§ answer

basics

solid answer

code

§ go deeper

▾level notes4 levels

▾deep dive~2 min

Compile flags are bit masks

Inline flags concatenate

Equivalence and when to use which

Flags with no inline letter

Pitfalls

Deriving the answer

▾common follow-ups2 questions

▾red flags4 flags

§ context

▾related questions5 questions

▾related topics1 topic

Compile flags are bit masks

Inline flags concatenate

Equivalence and when to use which

Flags with no inline letter

Pitfalls

Deriving the answer

answer

go deeper

context