Java Pattern.flags Method
Last modified: April 20, 2025
The Pattern.flags method returns the match flags specified when
the Pattern was compiled. These flags modify how the regular expression pattern
is interpreted during matching operations.
Flags can be combined using bitwise OR operations to enable multiple behaviors simultaneously. The method returns an integer representing the bitmask of all enabled flags for the Pattern instance.
Pattern Flags Overview
Java's Pattern class provides several flags that alter regex matching behavior.
Common flags include CASE_INSENSITIVE, MULTILINE, and
DOTALL. Each flag is represented by a constant integer value in the
Pattern class.
The flags method is useful when you need to inspect which flags are
active on a compiled Pattern object. This can help with debugging or when
creating new Pattern instances with similar settings.
Basic flags Method Usage
This example demonstrates the basic usage of the flags method to
retrieve the flags from a compiled Pattern. We'll create patterns with different
flag combinations and examine their values.
package com.zetcode;
import java.util.regex.Pattern;
public class PatternFlagsBasic {
public static void main(String[] args) {
// Pattern with no flags
Pattern noFlags = Pattern.compile("abc");
System.out.println("No flags: " + noFlags.flags());
// Pattern with CASE_INSENSITIVE flag
Pattern caseInsensitive = Pattern.compile("abc", Pattern.CASE_INSENSITIVE);
System.out.println("CASE_INSENSITIVE: " + caseInsensitive.flags());
// Pattern with multiple flags
Pattern multiFlags = Pattern.compile("abc",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
System.out.println("Multiple flags: " + multiFlags.flags());
}
}
In this example, we create three Pattern instances with different flag
combinations. The flags method returns an integer representing the
bitmask of all enabled flags for each Pattern.
The output will show the numeric values of the flag combinations. These values can be compared with the Pattern class constants to determine which flags are set.
Checking Individual Flags
This example shows how to check for specific flags using the flags() method return value. We'll use bitwise operations to test which flags are enabled.
package com.zetcode;
import java.util.regex.Pattern;
public class PatternCheckFlags {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("^[a-z]+$",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
int flags = pattern.flags();
System.out.println("All flags: " + flags);
System.out.println("CASE_INSENSITIVE enabled: " +
((flags & Pattern.CASE_INSENSITIVE) != 0));
System.out.println("MULTILINE enabled: " +
((flags & Pattern.MULTILINE) != 0));
System.out.println("DOTALL enabled: " +
((flags & Pattern.DOTALL) != 0));
System.out.println("UNICODE_CASE enabled: " +
((flags & Pattern.UNICODE_CASE) != 0));
}
}
Here we create a Pattern with CASE_INSENSITIVE and MULTILINE flags. We then use bitwise AND operations to check which individual flags are set in the returned flags value.
The output demonstrates how to verify the presence of specific flags in the Pattern's configuration. This technique is useful for conditional logic based on Pattern settings.
Reconstructing Pattern with Same Flags
This example shows how to use the flags method to create a new
Pattern with the same flags as an existing one. This is useful when you need to
modify a regex but keep the same matching behavior.
package com.zetcode;
import java.util.regex.Pattern;
public class PatternReuseFlags {
public static void main(String[] args) {
Pattern original = Pattern.compile("^start.*end$",
Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
// Get flags from original pattern
int flags = original.flags();
// Create new pattern with same flags but different regex
Pattern modified = Pattern.compile("^begin.*finish$", flags);
System.out.println("Original flags: " + original.flags());
System.out.println("Modified flags: " + modified.flags());
// Verify both patterns have same flags
System.out.println("Flags match: " +
(original.flags() == modified.flags()));
}
}
In this example, we first create a Pattern with specific flags. We
then extract those flags and use them to create a new Pattern with
a different regular expression but the same matching behavior.
This technique ensures consistent matching behavior across different patterns when flag settings need to be preserved.
Flags with Pattern.quote
This example demonstrates how flags interact with Pattern.quote.
The flags method will return 0 for patterns created with
quote since no special matching behavior is applied to literal
quoted strings.
package com.zetcode;
import java.util.regex.Pattern;
public class PatternQuoteFlags {
public static void main(String[] args) {
String regex = "[a-z]+";
Pattern normalPattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
// Create quoted pattern
Pattern quotedPattern = Pattern.compile(Pattern.quote(regex));
System.out.println("Normal pattern flags: " + normalPattern.flags());
System.out.println("Quoted pattern flags: " + quotedPattern.flags());
// Attempt to add flags to quoted pattern
Pattern quotedWithFlags = Pattern.compile(Pattern.quote(regex),
Pattern.CASE_INSENSITIVE);
System.out.println("Quoted with flags: " + quotedWithFlags.flags());
}
}
This example shows that Pattern.quote creates patterns with no
flags by default. Even when flags are specified, they have no effect on the
matching behavior of quoted patterns since they match literally.
The output demonstrates that quoted patterns maintain their flags
return value regardless of any flags specified during compilation.
Flags and Pattern.split
This example examines how flags affect the Pattern.split method.
We'll see how different flags change the splitting behavior and how to inspect
those flags.
package com.zetcode;
import java.util.regex.Pattern;
public class PatternSplitFlags {
public static void main(String[] args) {
String input = "Apple\nBanana\nCherry";
String regex = "^";
// Split with MULTILINE flag
Pattern multiline = Pattern.compile(regex, Pattern.MULTILINE);
String[] multilineResult = multiline.split(input);
System.out.println("Multiline split count: " + multilineResult.length);
System.out.println("Multiline flags: " + multiline.flags());
// Split without MULTILINE flag
Pattern normal = Pattern.compile(regex);
String[] normalResult = normal.split(input);
System.out.println("Normal split count: " + normalResult.length);
System.out.println("Normal flags: " + normal.flags());
}
}
In this example, we demonstrate how the MULTILINE flag affects the
split operation. With MULTILINE, the ^ anchor matches at the start
of each line, creating more splits than without the flag.
The flags method helps verify which flags are active on each
Pattern instance, explaining their different splitting behaviors.
Flags Inheritance in Pattern.matcher
This example shows that Matcher instances inherit their flags from
the Pattern that created them. The flags method helps confirm this
inheritance.
package com.zetcode;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PatternMatcherFlags {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("^[a-z]+$",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
Matcher matcher = pattern.matcher("Test");
// Verify matcher uses pattern's flags
System.out.println("Pattern flags: " + pattern.flags());
System.out.println("Does 'Test' match? " + matcher.matches());
// Change would require new Pattern with different flags
Pattern noFlags = Pattern.compile("^[a-z]+$");
Matcher strictMatcher = noFlags.matcher("Test");
System.out.println("No flags pattern: " + noFlags.flags());
System.out.println("Does 'Test' match now? " + strictMatcher.matches());
}
}
This example demonstrates that Matcher instances cannot modify the
flags of their parent Pattern. The flags method confirms that any
flag changes require creating a new Pattern instance.
The output shows how different flag settings affect matching behavior and how
the flags method can help debug these differences.
Source
Java Pattern.flags Documentation
In this article, we've explored the Pattern.flags method in depth,
showing how to use it to inspect and work with regular expression flags in Java.
Author
List all Java tutorials.