Package org.apache.commons.lang3

Class RegExUtils

java.lang.Object

org.apache.commons.lang3.RegExUtils

public class RegExUtils
extends Object

Helpers to process Strings using regular expressions.

Since:

3.8

See Also:

• Pattern

Constructor Summary

Constructors

Constructor	Description
RegExUtils()	Deprecated. TODO Make private in 4.0.

Method Summary

Modifier and Type	Method	Description
static Pattern	dotAll(String regex)	Compiles the given regular expression into a pattern with the Pattern.DOTALL flag.
static Matcher	dotAllMatcher(String regex, String text)	Compiles the given regular expression into a pattern with the Pattern.DOTALL flag, then creates a matcher that will match the given text against this pattern.
static String	removeAll(String text, String regex)	Removes each substring of the text String that matches the given regular expression.
static String	removeAll(String text, Pattern regex)	Removes each substring of the text String that matches the given regular expression pattern.
static String	removeFirst(String text, String regex)	Removes the first substring of the text string that matches the given regular expression.
static String	removeFirst(String text, Pattern regex)	Removes the first substring of the text string that matches the given regular expression pattern.
static String	removePattern(String text, String regex)	Removes each substring of the source String that matches the given regular expression using the DOTALL option.
static String	replaceAll(String text, String regex, String replacement)	Replaces each substring of the text String that matches the given regular expression with the given replacement.
static String	replaceAll(String text, Pattern regex, String replacement)	Replaces each substring of the text String that matches the given regular expression pattern with the given replacement.
static String	replaceFirst(String text, String regex, String replacement)	Replaces the first substring of the text string that matches the given regular expression with the given replacement.
static String	replaceFirst(String text, Pattern regex, String replacement)	Replaces the first substring of the text string that matches the given regular expression pattern with the given replacement.
static String	replacePattern(String text, String regex, String replacement)	Replaces each substring of the source String that matches the given regular expression with the given replacement using the Pattern.DOTALL option.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

RegExUtils

@Deprecated
public RegExUtils()

Deprecated.

TODO Make private in 4.0.

Make private in 4.0.

Method Details

dotAll

public static Pattern dotAll(String regex)

Compiles the given regular expression into a pattern with the Pattern.DOTALL flag.

Parameters:

regex - The expression to be compiled

Returns:

the given regular expression compiled into a pattern with the Pattern.DOTALL flag.

Since:

3.13.0

dotAllMatcher

public static Matcher dotAllMatcher(String regex,
 String text)

Compiles the given regular expression into a pattern with the Pattern.DOTALL flag, then creates a matcher that will match the given text against this pattern.

Parameters:

regex - The expression to be compiled.

text - The character sequence to be matched.

Returns:

A new matcher for this pattern.

Since:

3.13.0

removeAll

public static String removeAll(String text,
 Pattern regex)

Removes each substring of the text String that matches the given regular expression pattern. This method is a null safe equivalent to:

• pattern.matcher(text).replaceAll(StringUtils.EMPTY)

A null reference passed to this method is a no-op.

 StringUtils.removeAll(null, *)      = null
 StringUtils.removeAll("any", (Pattern) null)  = "any"
 StringUtils.removeAll("any", Pattern.compile(""))    = "any"
 StringUtils.removeAll("any", Pattern.compile(".*"))  = ""
 StringUtils.removeAll("any", Pattern.compile(".+"))  = ""
 StringUtils.removeAll("abc", Pattern.compile(".?"))  = ""
 StringUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>"))      = "A\nB"
 StringUtils.removeAll("A<__>\n<__>B", Pattern.compile("(?s)<.*>"))  = "AB"
 StringUtils.removeAll("A<__>\n<__>B", Pattern.compile("<.*>", Pattern.DOTALL))  = "AB"
 StringUtils.removeAll("ABCabc123abc", Pattern.compile("[a-z]"))     = "ABC123"
 

Parameters:

text - text to remove from, may be null

regex - the regular expression to which this string is to be matched

Returns:

the text with any removes processed, null if null String input

See Also:

• replaceAll(String, Pattern, String)
• Matcher.replaceAll(String)
• Pattern

removeAll

public static String removeAll(String text,
 String regex)

Removes each substring of the text String that matches the given regular expression. This method is a null safe equivalent to:

• text.replaceAll(regex, StringUtils.EMPTY)
• Pattern.compile(regex).matcher(text).replaceAll(StringUtils.EMPTY)

A null reference passed to this method is a no-op.

Unlike in the removePattern(String, String) method, the Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.

 StringUtils.removeAll(null, *)      = null
 StringUtils.removeAll("any", (String) null)  = "any"
 StringUtils.removeAll("any", "")    = "any"
 StringUtils.removeAll("any", ".*")  = ""
 StringUtils.removeAll("any", ".+")  = ""
 StringUtils.removeAll("abc", ".?")  = ""
 StringUtils.removeAll("A<__>\n<__>B", "<.*>")      = "A\nB"
 StringUtils.removeAll("A<__>\n<__>B", "(?s)<.*>")  = "AB"
 StringUtils.removeAll("ABCabc123abc", "[a-z]")     = "ABC123"
 

Parameters:

text - text to remove from, may be null

regex - the regular expression to which this string is to be matched

Returns:

the text with any removes processed, null if null String input

Throws:

PatternSyntaxException - if the regular expression's syntax is invalid

See Also:

• replaceAll(String, String, String)
• removePattern(String, String)
• String.replaceAll(String, String)
• Pattern
• Pattern.DOTALL

removeFirst

public static String removeFirst(String text,
 Pattern regex)

Removes the first substring of the text string that matches the given regular expression pattern. This method is a null safe equivalent to:

• pattern.matcher(text).replaceFirst(StringUtils.EMPTY)

A null reference passed to this method is a no-op.

 StringUtils.removeFirst(null, *)      = null
 StringUtils.removeFirst("any", (Pattern) null)  = "any"
 StringUtils.removeFirst("any", Pattern.compile(""))    = "any"
 StringUtils.removeFirst("any", Pattern.compile(".*"))  = ""
 StringUtils.removeFirst("any", Pattern.compile(".+"))  = ""
 StringUtils.removeFirst("abc", Pattern.compile(".?"))  = "bc"
 StringUtils.removeFirst("A<__>\n<__>B", Pattern.compile("<.*>"))      = "A\n<__>B"
 StringUtils.removeFirst("A<__>\n<__>B", Pattern.compile("(?s)<.*>"))  = "AB"
 StringUtils.removeFirst("ABCabc123", Pattern.compile("[a-z]"))          = "ABCbc123"
 StringUtils.removeFirst("ABCabc123abc", Pattern.compile("[a-z]+"))      = "ABC123abc"
 

Parameters:

text - text to remove from, may be null

regex - the regular expression pattern to which this string is to be matched

Returns:

the text with the first replacement processed, null if null String input

See Also:

• replaceFirst(String, Pattern, String)
• Matcher.replaceFirst(String)
• Pattern

removeFirst

public static String removeFirst(String text,
 String regex)

Removes the first substring of the text string that matches the given regular expression. This method is a null safe equivalent to:

• text.replaceFirst(regex, StringUtils.EMPTY)
• Pattern.compile(regex).matcher(text).replaceFirst(StringUtils.EMPTY)

A null reference passed to this method is a no-op.

The Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.

 StringUtils.removeFirst(null, *)      = null
 StringUtils.removeFirst("any", (String) null)  = "any"
 StringUtils.removeFirst("any", "")    = "any"
 StringUtils.removeFirst("any", ".*")  = ""
 StringUtils.removeFirst("any", ".+")  = ""
 StringUtils.removeFirst("abc", ".?")  = "bc"
 StringUtils.removeFirst("A<__>\n<__>B", "<.*>")      = "A\n<__>B"
 StringUtils.removeFirst("A<__>\n<__>B", "(?s)<.*>")  = "AB"
 StringUtils.removeFirst("ABCabc123", "[a-z]")          = "ABCbc123"
 StringUtils.removeFirst("ABCabc123abc", "[a-z]+")      = "ABC123abc"
 

Parameters:

text - text to remove from, may be null

regex - the regular expression to which this string is to be matched

Returns:

the text with the first replacement processed, null if null String input

Throws:

PatternSyntaxException - if the regular expression's syntax is invalid

See Also:

• replaceFirst(String, String, String)
• String.replaceFirst(String, String)
• Pattern
• Pattern.DOTALL

removePattern

public static String removePattern(String text,
 String regex)

Removes each substring of the source String that matches the given regular expression using the DOTALL option. This call is a null safe equivalent to:

• text.replaceAll("(?s)" + regex, StringUtils.EMPTY)
• Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(StringUtils.EMPTY)

A null reference passed to this method is a no-op.

 StringUtils.removePattern(null, *)       = null
 StringUtils.removePattern("any", (String) null)   = "any"
 StringUtils.removePattern("A<__>\n<__>B", "<.*>")  = "AB"
 StringUtils.removePattern("ABCabc123", "[a-z]")    = "ABC123"
 

Parameters:

text - the source string

regex - the regular expression to which this string is to be matched

Returns:

The resulting String

See Also:

• replacePattern(String, String, String)
• String.replaceAll(String, String)
• Pattern.DOTALL

replaceAll

public static String replaceAll(String text,
 Pattern regex,
 String replacement)

Replaces each substring of the text String that matches the given regular expression pattern with the given replacement. This method is a null safe equivalent to:

• pattern.matcher(text).replaceAll(replacement)

A null reference passed to this method is a no-op.

 StringUtils.replaceAll(null, *, *)       = null
 StringUtils.replaceAll("any", (Pattern) null, *)   = "any"
 StringUtils.replaceAll("any", *, null)   = "any"
 StringUtils.replaceAll("", Pattern.compile(""), "zzz")    = "zzz"
 StringUtils.replaceAll("", Pattern.compile(".*"), "zzz")  = "zzz"
 StringUtils.replaceAll("", Pattern.compile(".+"), "zzz")  = ""
 StringUtils.replaceAll("abc", Pattern.compile(""), "ZZ")  = "ZZaZZbZZcZZ"
 StringUtils.replaceAll("<__>\n<__>", Pattern.compile("<.*>"), "z")                 = "z\nz"
 StringUtils.replaceAll("<__>\n<__>", Pattern.compile("<.*>", Pattern.DOTALL), "z") = "z"
 StringUtils.replaceAll("<__>\n<__>", Pattern.compile("(?s)<.*>"), "z")             = "z"
 StringUtils.replaceAll("ABCabc123", Pattern.compile("[a-z]"), "_")       = "ABC___123"
 StringUtils.replaceAll("ABCabc123", Pattern.compile("[^A-Z0-9]+"), "_")  = "ABC_123"
 StringUtils.replaceAll("ABCabc123", Pattern.compile("[^A-Z0-9]+"), "")   = "ABC123"
 StringUtils.replaceAll("Lorem ipsum  dolor   sit", Pattern.compile("( +)([a-z]+)"), "_$2")  = "Lorem_ipsum_dolor_sit"
 

Parameters:

text - text to search and replace in, may be null

regex - the regular expression pattern to which this string is to be matched

replacement - the string to be substituted for each match

Returns:

the text with any replacements processed, null if null String input

See Also:

• Matcher.replaceAll(String)
• Pattern

replaceAll

public static String replaceAll(String text,
 String regex,
 String replacement)

Replaces each substring of the text String that matches the given regular expression with the given replacement. This method is a null safe equivalent to:

• text.replaceAll(regex, replacement)
• Pattern.compile(regex).matcher(text).replaceAll(replacement)

A null reference passed to this method is a no-op.

Unlike in the replacePattern(String, String, String) method, the Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.

 StringUtils.replaceAll(null, *, *)       = null
 StringUtils.replaceAll("any", (String) null, *)   = "any"
 StringUtils.replaceAll("any", *, null)   = "any"
 StringUtils.replaceAll("", "", "zzz")    = "zzz"
 StringUtils.replaceAll("", ".*", "zzz")  = "zzz"
 StringUtils.replaceAll("", ".+", "zzz")  = ""
 StringUtils.replaceAll("abc", "", "ZZ")  = "ZZaZZbZZcZZ"
 StringUtils.replaceAll("<__>\n<__>", "<.*>", "z")      = "z\nz"
 StringUtils.replaceAll("<__>\n<__>", "(?s)<.*>", "z")  = "z"
 StringUtils.replaceAll("ABCabc123", "[a-z]", "_")       = "ABC___123"
 StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "_")  = "ABC_123"
 StringUtils.replaceAll("ABCabc123", "[^A-Z0-9]+", "")   = "ABC123"
 StringUtils.replaceAll("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum_dolor_sit"
 

Parameters:

text - text to search and replace in, may be null

regex - the regular expression to which this string is to be matched

replacement - the string to be substituted for each match

Returns:

the text with any replacements processed, null if null String input

Throws:

PatternSyntaxException - if the regular expression's syntax is invalid

See Also:

• replacePattern(String, String, String)
• String.replaceAll(String, String)
• Pattern
• Pattern.DOTALL

replaceFirst

public static String replaceFirst(String text,
 Pattern regex,
 String replacement)

Replaces the first substring of the text string that matches the given regular expression pattern with the given replacement. This method is a null safe equivalent to:

• pattern.matcher(text).replaceFirst(replacement)

A null reference passed to this method is a no-op.

 StringUtils.replaceFirst(null, *, *)       = null
 StringUtils.replaceFirst("any", (Pattern) null, *)   = "any"
 StringUtils.replaceFirst("any", *, null)   = "any"
 StringUtils.replaceFirst("", Pattern.compile(""), "zzz")    = "zzz"
 StringUtils.replaceFirst("", Pattern.compile(".*"), "zzz")  = "zzz"
 StringUtils.replaceFirst("", Pattern.compile(".+"), "zzz")  = ""
 StringUtils.replaceFirst("abc", Pattern.compile(""), "ZZ")  = "ZZabc"
 StringUtils.replaceFirst("<__>\n<__>", Pattern.compile("<.*>"), "z")      = "z\n<__>"
 StringUtils.replaceFirst("<__>\n<__>", Pattern.compile("(?s)<.*>"), "z")  = "z"
 StringUtils.replaceFirst("ABCabc123", Pattern.compile("[a-z]"), "_")          = "ABC_bc123"
 StringUtils.replaceFirst("ABCabc123abc", Pattern.compile("[^A-Z0-9]+"), "_")  = "ABC_123abc"
 StringUtils.replaceFirst("ABCabc123abc", Pattern.compile("[^A-Z0-9]+"), "")   = "ABC123abc"
 StringUtils.replaceFirst("Lorem ipsum  dolor   sit", Pattern.compile("( +)([a-z]+)"), "_$2")  = "Lorem_ipsum  dolor   sit"
 

Parameters:

text - text to search and replace in, may be null

regex - the regular expression pattern to which this string is to be matched

replacement - the string to be substituted for the first match

Returns:

the text with the first replacement processed, null if null String input

See Also:

• Matcher.replaceFirst(String)
• Pattern

replaceFirst

public static String replaceFirst(String text,
 String regex,
 String replacement)

Replaces the first substring of the text string that matches the given regular expression with the given replacement. This method is a null safe equivalent to:

• text.replaceFirst(regex, replacement)
• Pattern.compile(regex).matcher(text).replaceFirst(replacement)

A null reference passed to this method is a no-op.

The Pattern.DOTALL option is NOT automatically added. To use the DOTALL option prepend "(?s)" to the regex. DOTALL is also known as single-line mode in Perl.

 StringUtils.replaceFirst(null, *, *)       = null
 StringUtils.replaceFirst("any", (String) null, *)   = "any"
 StringUtils.replaceFirst("any", *, null)   = "any"
 StringUtils.replaceFirst("", "", "zzz")    = "zzz"
 StringUtils.replaceFirst("", ".*", "zzz")  = "zzz"
 StringUtils.replaceFirst("", ".+", "zzz")  = ""
 StringUtils.replaceFirst("abc", "", "ZZ")  = "ZZabc"
 StringUtils.replaceFirst("<__>\n<__>", "<.*>", "z")      = "z\n<__>"
 StringUtils.replaceFirst("<__>\n<__>", "(?s)<.*>", "z")  = "z"
 StringUtils.replaceFirst("ABCabc123", "[a-z]", "_")          = "ABC_bc123"
 StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "_")  = "ABC_123abc"
 StringUtils.replaceFirst("ABCabc123abc", "[^A-Z0-9]+", "")   = "ABC123abc"
 StringUtils.replaceFirst("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum  dolor   sit"
 

Parameters:

text - text to search and replace in, may be null

regex - the regular expression to which this string is to be matched

replacement - the string to be substituted for the first match

Returns:

the text with the first replacement processed, null if null String input

Throws:

PatternSyntaxException - if the regular expression's syntax is invalid

See Also:

• String.replaceFirst(String, String)
• Pattern
• Pattern.DOTALL

replacePattern

public static String replacePattern(String text,
 String regex,
 String replacement)

Replaces each substring of the source String that matches the given regular expression with the given replacement using the Pattern.DOTALL option. DOTALL is also known as single-line mode in Perl. This call is a null safe equivalent to:

• text.replaceAll("(?s)" + regex, replacement)
• Pattern.compile(regex, Pattern.DOTALL).matcher(text).replaceAll(replacement)

A null reference passed to this method is a no-op.

 StringUtils.replacePattern(null, *, *)       = null
 StringUtils.replacePattern("any", (String) null, *)   = "any"
 StringUtils.replacePattern("any", *, null)   = "any"
 StringUtils.replacePattern("", "", "zzz")    = "zzz"
 StringUtils.replacePattern("", ".*", "zzz")  = "zzz"
 StringUtils.replacePattern("", ".+", "zzz")  = ""
 StringUtils.replacePattern("<__>\n<__>", "<.*>", "z")       = "z"
 StringUtils.replacePattern("ABCabc123", "[a-z]", "_")       = "ABC___123"
 StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "_")  = "ABC_123"
 StringUtils.replacePattern("ABCabc123", "[^A-Z0-9]+", "")   = "ABC123"
 StringUtils.replacePattern("Lorem ipsum  dolor   sit", "( +)([a-z]+)", "_$2")  = "Lorem_ipsum_dolor_sit"
 

Parameters:

text - the source string

regex - the regular expression to which this string is to be matched

replacement - the string to be substituted for each match

Returns:

The resulting String

See Also:

• replaceAll(String, String, String)
• String.replaceAll(String, String)
• Pattern.DOTALL